mod audit;
mod auth;
mod config;
mod embed;
mod index;
mod links;
mod mcp;
mod model;
mod store;
mod web;
use anyhow::Result;
use axum::extract::rejection::QueryRejection;
use axum::extract::{FromRequestParts, Path, Query, State};
use axum::response::{IntoResponse, Response};
use axum::http::StatusCode;
use axum::middleware;
use axum::routing::{get, post};
use axum::{Json, Router};
use serde::Deserialize;
use serde_json::{json, Value};
use std::collections::HashSet;
use std::net::SocketAddr;
use std::sync::Arc;
use tantivy::IndexWriter;
use tokio::sync::Mutex;
pub struct AppState {
store: store::Store,
index: index::SearchIndex,
audit: audit::Audit,
semantic: Option<embed::Semantic>,
writer: Mutex<IndexWriter>,
pub(crate) audit_path: std::path::PathBuf,
history_index: std::sync::Mutex<Option<Arc<store::HistoryIndex>>>,
history_gen: std::sync::atomic::AtomicU64,
links_cache: std::sync::Mutex<Option<LinksCache>>,
archived_since: std::sync::Mutex<Vec<(u64, String)>>,
note_seq: std::sync::atomic::AtomicU64,
pub(crate) auth: auth::Auth,
}
struct LinksCache {
gen: u64,
index: Arc<links::LinkIndex>,
archived: Arc<std::collections::HashMap<String, model::Entry>>,
}
impl AppState {
fn note_archived(&self, key: &str) {
let n = self.note_seq.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
self.archived_since.lock().unwrap().push((n, key.to_string()));
}
fn settle_notes(&self, read: &[(u64, String)]) {
let mut since = self.archived_since.lock().unwrap();
since.retain(|(n, _)| !read.iter().any(|(r, _)| r == n));
}
fn links(&self) -> Result<Arc<links::LinkIndex>> {
use std::sync::atomic::Ordering;
let gen = self.history_gen.load(Ordering::Acquire);
let prev = {
let held = self.links_cache.lock().unwrap();
match held.as_ref() {
Some(c) if c.gen == gen => return Ok(c.index.clone()),
Some(c) => Some(((), c.archived.clone())),
None => None,
}
};
let noted: Vec<(u64, String)> = self.archived_since.lock().unwrap().clone();
let head = self.store.list_head()?;
let head_kinds: HashSet<String> = head.iter().map(|e| e.key.clone()).collect();
let archived: Arc<std::collections::HashMap<String, model::Entry>> = match prev {
None => Arc::new(self.store.archived_latest()?.into_iter().map(|e| (e.key.clone(), e)).collect()),
Some((_, archived)) => {
let mut next = (*archived).clone();
next.retain(|k, _| !head_kinds.contains(k));
for key in noted.iter().map(|(_, k)| k).filter(|k| !head_kinds.contains(*k)) {
if let Some(last) = self.store.latest_version(key)? {
next.insert(key.clone(), last);
}
}
Arc::new(next)
}
};
let archived_list: Vec<model::Entry> = archived.values().cloned().collect();
let index = Arc::new(links::LinkIndex::build(&head, &archived_list));
if self.history_gen.load(Ordering::Acquire) == gen {
*self.links_cache.lock().unwrap() = Some(LinksCache { gen, index: index.clone(), archived });
self.settle_notes(¬ed);
}
Ok(index)
}
fn history_index(&self) -> Result<Arc<store::HistoryIndex>> {
let mut held = self.history_index.lock().unwrap();
let head = self.store.head_info()?.map(|(sha, _)| sha);
if let Some(ix) = held.as_ref() {
if ix.head == head {
return Ok(ix.clone());
}
}
let next = Arc::new(self.store.history_index(held.as_deref())?);
*held = Some(next.clone());
Ok(next)
}
fn history_cached(&self, key: &str) -> Result<Vec<store::VersionInfo>> {
Ok(self.history_index()?.versions(key))
}
fn archived_version(&self, key: &str) -> Result<Option<model::Entry>> {
let versions = self.history_cached(key)?;
match versions.iter().find(|v| v.change == "deleted") {
Some(del) => self.store.get_at(key, &format!("{}^", del.sha)),
None => self.store.latest_version(key),
}
}
fn note_write(&self, _key: &str) {
self.history_gen.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
}
}
type St = State<Arc<AppState>>;
type Reply = (StatusCode, Json<Value>);
fn embed_text(e: &model::Entry) -> String {
let body: String = e.body.chars().take(1200).collect();
if e.is_incident() {
format!("{}. Incident on {} ({}). {}", e.title, e.service, e.hosts.join(", "), body)
} else {
format!("{}. {}", e.title, body)
}
}
fn vector_docs(st: &AppState) -> Option<Vec<(String, String)>> {
st.semantic.as_ref()?;
let mut entries = match st.store.list_head() {
Ok(v) => v,
Err(e) => {
eprintln!("kyb: cannot list canon for embeddings: {e:#}");
return None;
}
};
match st.store.archived_latest() {
Ok(mut archived) => entries.append(&mut archived),
Err(e) => eprintln!("kyb: archived entries not embedded: {e:#}"),
}
Some(entries.iter().map(|e| (e.key.clone(), embed_text(e))).collect())
}
async fn finish_vector_rebuild(st: &AppState, job: embed::RebuildJob) {
let Some(sem) = st.semantic.as_ref() else { return };
match sem.finish_rebuild(job).await {
Ok(n) => eprintln!("kyb: embedded {n} entries"),
Err(e) => eprintln!("kyb: embedding failed, staying lexical: {e:#}"),
}
}
async fn rebuild_vectors(st: &AppState) {
let Some(sem) = st.semantic.as_ref() else { return };
let writer = st.writer.lock().await;
let Some(docs) = vector_docs(st) else { return };
let job = sem.begin_rebuild(docs).await;
drop(writer);
finish_vector_rebuild(st, job).await;
}
fn build_state(cfg: &config::Config) -> Result<Arc<AppState>> {
build_state_with(cfg, auth::Auth::from_env()?)
}
fn build_state_with(cfg: &config::Config, auth: auth::Auth) -> Result<Arc<AppState>> {
let store = store::Store::open(&cfg.data_dir)?;
auth.refuse_inside(&cfg.data_dir)?;
let index = index::SearchIndex::open_or_create(&cfg.index_dir)?;
let mut writer = index.writer()?;
let (heads, hist) = index.reindex(&mut writer, &store)?;
eprintln!("kyb: reindex on start — {heads} head entries, {hist} history versions");
let audit = audit::Audit::open(&cfg.audit_path)?;
let model_start = std::time::Instant::now();
let semantic = match embed::Semantic::load(&cfg.model_dir, cfg.index_dir.join("vectors.cache")) {
Ok(s) => {
eprintln!(
"kyb: semantic search on ({}) — model loaded in {:.1}s",
cfg.model_dir.display(),
model_start.elapsed().as_secs_f64()
);
Some(s)
}
Err(e) => {
eprintln!("kyb: lexical-only search ({e})");
None
}
};
let st = Arc::new(AppState {
store,
index,
audit,
semantic,
writer: Mutex::new(writer),
audit_path: cfg.audit_path.clone(),
history_index: std::sync::Mutex::new(None),
history_gen: std::sync::atomic::AtomicU64::new(0),
links_cache: std::sync::Mutex::new(None),
archived_since: std::sync::Mutex::new(Vec::new()),
note_seq: std::sync::atomic::AtomicU64::new(0),
auth,
});
let walk = std::time::Instant::now();
match st.history_index() {
Ok(ix) => eprintln!("kyb: history index — {} keys in {:.1}s", ix.keys().count(), walk.elapsed().as_secs_f64()),
Err(e) => eprintln!("kyb: history index not built ({e:#}); versions and diffs will try again on request"),
}
Ok(st)
}
fn build_app(state: Arc<AppState>) -> Router {
let api = api_router(state);
api.clone().merge(mcp::router(api))
}
fn api_router(state: Arc<AppState>) -> Router {
Router::new()
.route("/", get(web::serve_ui))
.route("/api/audit", get(web::api_audit))
.route("/api/activity", get(web::api_activity))
.route("/healthz", get(healthz))
.route("/whoami", get(auth::whoami))
.route("/knowledge", post(upsert))
.route("/knowledge/{key}", get(get_one).delete(remove))
.route("/knowledge/{key}/history", get(history))
.route("/knowledge/{key}/diff", get(diff))
.route("/knowledge/{key}/related", get(related))
.route("/places", get(places))
.route("/impact", get(impact))
.route("/incidents", post(upsert_incident).get(list_incidents))
.route("/incidents/{key}/resolve", post(resolve_incident))
.route("/tasks", post(upsert_task).get(list_tasks))
.route("/tasks/{key}/resolve", post(resolve_task))
.route("/tasks/{key}/transition", post(transition_task))
.route("/search", get(search))
.route("/tags", get(tags))
.route("/reindex", post(reindex))
.layer(middleware::from_fn_with_state(state.clone(), auth::auth_mw))
.layer(middleware::from_fn_with_state(state.clone(), audit::audit_mw))
.with_state(state)
}
#[tokio::main]
async fn main() -> Result<()> {
let boot = std::time::Instant::now();
let cfg = config::Config::from_env();
let args: Vec<String> = std::env::args().skip(1).collect();
if args.first().map(String::as_str) == Some("auth") {
match auth::cli(&args[1..]) {
Ok(out) => println!("{out}"),
Err(e) => {
eprintln!("{e:#}");
std::process::exit(2);
}
}
return Ok(());
}
let state = build_state(&cfg)?;
let indexed = boot.elapsed();
rebuild_vectors(&state).await;
let ready = boot.elapsed();
let state_auth_line = state.auth.describe();
let app = build_app(state);
let listener = tokio::net::TcpListener::bind(&cfg.addr).await?;
eprintln!(
"kyb: ready in {:.1}s (canon, index and model load {:.1}s, embeddings {:.1}s)",
ready.as_secs_f64(),
indexed.as_secs_f64(),
(ready - indexed).as_secs_f64()
);
eprintln!("kyb: listening on http://{}", cfg.addr);
eprintln!("kyb: {}", state_auth_line);
axum::serve(listener, app.into_make_service_with_connect_info::<SocketAddr>()).await?;
Ok(())
}
fn err500(e: anyhow::Error) -> Reply {
(StatusCode::INTERNAL_SERVER_ERROR, Json(json!({"error": format!("{e:#}")})))
}
pub struct Q<T>(pub T);
impl<S, T> FromRequestParts<S> for Q<T>
where
Query<T>: FromRequestParts<S, Rejection = QueryRejection>,
S: Send + Sync,
{
type Rejection = Response;
async fn from_request_parts(
parts: &mut axum::http::request::Parts,
state: &S,
) -> Result<Self, Self::Rejection> {
match Query::<T>::from_request_parts(parts, state).await {
Ok(Query(value)) => Ok(Q(value)),
Err(rejection) => Err((
StatusCode::BAD_REQUEST,
Json(json!({"error": rejection.body_text()})),
)
.into_response()),
}
}
}
#[derive(Deserialize)]
struct UpsertReq {
key: String,
title: String,
body: String,
#[serde(default)]
tags: Vec<String>,
#[serde(default)]
refs: Vec<String>,
}
type Built = Result<(model::Entry, Value), Reply>;
async fn locked_write(st: &Arc<AppState>, build: impl FnOnce(&AppState) -> Built) -> Reply {
let mut w = st.writer.lock().await;
let (entry, extra) = match build(st.as_ref()) {
Ok(built) => built,
Err(reply) => return reply,
};
let closed = entry.is_closed();
let key = entry.key.clone();
st.note_write(&key);
let (mut reply, committed) = commit_locked(st, &mut w, entry, extra);
if closed {
archive_locked(st, &mut w, &key, &mut reply);
}
st.note_write(&key);
let pending = match (st.semantic.as_ref(), committed) {
(Some(sem), Some(entry)) => {
let ticket = sem.begin_upsert(&entry.key).await;
Some((ticket, entry))
}
_ => None,
};
drop(w);
if let (Some(sem), Some((ticket, entry))) = (st.semantic.as_ref(), pending) {
if let Err(err) = sem.finish_upsert(ticket, &embed_text(&entry)).await {
eprintln!("kyb: embedding not updated for {}: {err:#}", entry.key);
}
}
reply
}
fn commit_locked(
st: &AppState,
w: &mut IndexWriter,
entry: model::Entry,
extra: Value,
) -> (Reply, Option<model::Entry>) {
if let Err(e) = entry.validate() {
return ((StatusCode::BAD_REQUEST, Json(json!({"error": e.to_string()}))), None);
}
if let Err(e) = validate_task_parent_chain(st, &entry) {
return ((StatusCode::BAD_REQUEST, Json(json!({"error": e.to_string()}))), None);
}
let today = chrono::Local::now().format("%Y-%m-%d").to_string();
let had_history = matches!(st.store.get(&entry.key), Ok(None))
&& st.history_cached(&entry.key).map(|v| !v.is_empty()).unwrap_or(false);
let (c, action) = match st.store.upsert(entry, &today) {
Err(e) => return (err500(e), None),
Ok(store::UpsertOutcome::Unchanged(entry)) => {
return ((StatusCode::OK, Json(json!({"key": entry.key, "changed": false}))), None);
}
Ok(store::UpsertOutcome::Created(c)) => (c, "created"),
Ok(store::UpsertOutcome::Updated(c)) => (c, "updated"),
};
if let Err(e) = st
.index
.upsert_head(w, &c.entry, &c.sha, c.committed_at)
.and_then(|_| st.index.commit_and_reload(w))
{
return (
err500(e.context("git committed but the index was not updated — run POST /reindex")),
None,
);
}
let mut resp = json!({"key": c.entry.key, "sha": c.sha, "changed": true, "action": action});
if action == "created" {
let mut known: std::collections::HashSet<String> =
st.history_index().map(|ix| ix.keys().cloned().collect()).unwrap_or_default();
known.extend(st.store.list_head().unwrap_or_default().into_iter().map(|e| e.key));
let similar = model::similar_keys(&c.entry.key, known.iter().map(String::as_str));
if !similar.is_empty() {
resp["similar"] = json!(similar);
}
if had_history {
resp["revived"] = json!(true);
resp["hint"] = json!(format!(
"'{}' existed before and was retracted; see `kyb history {}` for why",
c.entry.key, c.entry.key
));
}
}
if let (Some(obj), Some(add)) = (resp.as_object_mut(), extra.as_object()) {
obj.extend(add.clone());
}
((StatusCode::OK, Json(resp)), Some(c.entry))
}
async fn upsert(State(st): St, Json(r): Json<UpsertReq>) -> Reply {
locked_write(&st, move |_| {
Ok((
model::Entry {
key: r.key,
title: r.title,
tags: r.tags,
refs: r.refs,
body: r.body,
..Default::default()
},
Value::Null,
))
})
.await
}
fn default_status() -> String {
"open".to_string()
}
#[derive(Deserialize)]
struct IncidentReq {
key: String,
title: String,
body: String,
service: String,
#[serde(default)]
hosts: Vec<String>,
severity: String,
#[serde(default = "default_status")]
status: String,
#[serde(default)]
knowledge: Vec<String>,
#[serde(default)]
resolution: String,
#[serde(default)]
detection: String,
#[serde(default)]
affected: Vec<model::Window>,
#[serde(default)]
started_at: String,
#[serde(default)]
detected_at: String,
#[serde(default)]
tags: Vec<String>,
#[serde(default)]
refs: Vec<String>,
}
fn now_utc() -> String {
chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true)
}
fn stored_version(st: &AppState, key: &str) -> Option<model::Entry> {
if let Ok(Some(e)) = st.store.get(key) {
return Some(e);
}
st.store.latest_version(key).ok().flatten().filter(|e| e.kind != model::KIND_KNOWLEDGE)
}
fn stamp_timeline(st: &AppState, entry: &mut model::Entry) {
if let Some(old) = stored_version(st, &entry.key) {
let inherit = [
(&mut entry.started_at, old.started_at),
(&mut entry.detected_at, old.detected_at),
(&mut entry.mitigated_at, old.mitigated_at),
(&mut entry.resolved_at, old.resolved_at),
];
for (field, stored) in inherit {
if field.trim().is_empty() {
*field = stored;
}
}
}
if entry.is_incident() && entry.detected_at.trim().is_empty() {
entry.detected_at = now_utc();
}
if entry.status == "mitigated" && entry.mitigated_at.trim().is_empty() {
entry.mitigated_at = now_utc();
}
if entry.is_closed() && entry.resolved_at.trim().is_empty() {
entry.resolved_at = now_utc();
}
}
async fn upsert_incident(State(st): St, Json(r): Json<IncidentReq>) -> Reply {
locked_write(&st, move |st| {
let mut entry = model::Entry {
key: r.key,
title: r.title,
kind: model::KIND_INCIDENT.into(),
service: r.service,
hosts: r.hosts,
severity: r.severity,
status: r.status,
knowledge: r.knowledge,
resolution: r.resolution,
detection: r.detection,
affected: r.affected,
started_at: r.started_at,
detected_at: r.detected_at,
tags: r.tags,
refs: r.refs,
body: r.body,
..Default::default()
};
stamp_timeline(st, &mut entry);
let mut unknown = vec![];
for k in &entry.knowledge {
if model::is_valid_key(k) && !matches!(st.store.get(k), Ok(Some(_))) {
unknown.push(k.clone());
}
}
let mut hints = vec![];
if entry.detection.trim().is_empty() {
hints.push("no detection: add an executable 'is it still happening?' check with the expected healthy result (--detection)");
}
if entry.affected.is_empty() {
hints.push("no affected windows: if data or a period got poisoned, record {scope,from,to} in --affected so backtests can exclude it programmatically");
}
if !entry.body.contains("- [ ]") && !entry.body.contains("- [x]") {
hints.push("no follow-ups: track loose ends in the body as '- [ ]' checklist items so they are not lost");
}
if !entry.body.to_lowercase().contains("root cause") {
hints.push("no 'Root cause' section: state it and mark the confidence — verified | suspected | unknown");
}
let mut extra = serde_json::Map::new();
if !unknown.is_empty() {
extra.insert("unknown_knowledge".into(), json!(unknown));
}
if !hints.is_empty() {
extra.insert("hints".into(), json!(hints));
}
let extra = if extra.is_empty() { Value::Null } else { Value::Object(extra) };
Ok((entry, extra))
})
.await
}
#[derive(Deserialize)]
struct ResolveReq {
#[serde(default, alias = "outcome")]
resolution: String,
status: Option<String>,
}
fn archive_locked(st: &AppState, _w: &mut IndexWriter, key: &str, reply: &mut Reply) {
if reply.0 != StatusCode::OK {
return;
}
match st.store.archive(key) {
Err(e) => eprintln!("kyb: archive failed for {key}: {e:#}"),
Ok(None) => {} Ok(Some(sha)) => {
st.note_archived(key);
if let Some(obj) = reply.1.as_object_mut() {
obj.insert("archived".into(), json!(true));
obj.insert("archive_sha".into(), json!(sha));
}
}
}
}
async fn close_entry(st: &Arc<AppState>, key: String, want_task: bool, r: ResolveReq) -> Reply {
if let Some(resp) = bad_key(&key) {
return resp;
}
locked_write(st, move |st| {
let Some(mut e) = stored_version(st, &key) else {
return Err((
StatusCode::NOT_FOUND,
Json(json!({"error": format!("no entry '{key}'")})),
));
};
if want_task != e.is_task() || (!want_task && !e.is_incident()) {
let what = if want_task { "a task" } else { "an incident report" };
return Err((
StatusCode::BAD_REQUEST,
Json(json!({"error": format!("'{key}' is not {what}")})),
));
}
let default_close = if want_task { "done" } else { "resolved" };
e.status = r.status.unwrap_or_else(|| default_close.to_string());
if e.status != model::STATUS_BLOCKED {
e.blocked_reason.clear();
}
if !r.resolution.trim().is_empty() {
e.resolution = r.resolution;
}
stamp_timeline(st, &mut e);
let open = e.open_followups();
let extra = if open > 0 && e.is_closed() {
json!({
"open_followups": open,
"warning": format!("{open} unfinished follow-up(s) (`- [ ]`) remain in the body — reassign or finish them"),
})
} else {
Value::Null
};
Ok((e, extra))
})
.await
}
async fn resolve_incident(
State(st): St,
Path(key): Path<String>,
Json(r): Json<ResolveReq>,
) -> Reply {
close_entry(&st, key, false, r).await
}
async fn resolve_task(State(st): St, Path(key): Path<String>, Json(r): Json<ResolveReq>) -> Reply {
close_entry(&st, key, true, r).await
}
fn unknown_parent(st: &AppState, entry: &model::Entry) -> Option<String> {
let parent = entry.parent_task.trim();
if parent.is_empty() || !model::is_valid_key(parent) {
return None;
}
stored_version(st, parent).is_none().then(|| parent.to_string())
}
fn validate_task_parent_chain(st: &AppState, entry: &model::Entry) -> Result<()> {
if !entry.is_task() || entry.parent_task.is_empty() {
return Ok(());
}
let mut cursor = entry.parent_task.clone();
let mut seen = HashSet::new();
while !cursor.is_empty() {
if cursor == entry.key {
anyhow::bail!(
"parent_task would create a cycle containing '{}'",
entry.key
);
}
if !seen.insert(cursor.clone()) {
anyhow::bail!("parent_task points into an existing task cycle at '{cursor}'");
}
let Some(parent) = stored_version(st, &cursor) else {
break;
};
cursor = parent.parent_task;
}
Ok(())
}
#[derive(Deserialize)]
struct TaskReq {
key: String,
title: String,
body: String,
#[serde(default = "default_status")]
status: String,
#[serde(default)]
priority: String,
#[serde(default)]
blocked_reason: String,
#[serde(default)]
assignee: String,
#[serde(default)]
parent_task: String,
#[serde(default)]
knowledge: Vec<String>,
#[serde(default)]
resolution: String,
#[serde(default)]
tags: Vec<String>,
#[serde(default)]
refs: Vec<String>,
}
async fn upsert_task(State(st): St, Json(r): Json<TaskReq>) -> Reply {
locked_write(&st, move |st| {
let mut entry = model::Entry {
key: r.key,
title: r.title,
kind: model::KIND_TASK.into(),
status: r.status,
priority: r.priority,
blocked_reason: r.blocked_reason,
assignee: r.assignee.trim().to_string(),
parent_task: r.parent_task.trim().to_string(),
knowledge: r.knowledge,
resolution: r.resolution,
tags: r.tags,
refs: r.refs,
body: r.body,
..Default::default()
};
if entry.is_closed() && entry.resolved_at.trim().is_empty() {
if let Ok(Some(old)) = st.store.get(&entry.key) {
entry.resolved_at = old.resolved_at;
}
if entry.resolved_at.trim().is_empty() {
entry.resolved_at = now_utc();
}
}
let mut unknown = vec![];
for k in &entry.knowledge {
if model::is_valid_key(k) && !matches!(st.store.get(k), Ok(Some(_))) {
unknown.push(k.clone());
}
}
let mut extra = serde_json::Map::new();
if !unknown.is_empty() {
extra.insert("unknown_knowledge".into(), json!(unknown));
}
if let Some(parent) = unknown_parent(st, &entry) {
extra.insert("unknown_parent".into(), json!(parent));
}
let extra = if extra.is_empty() { Value::Null } else { Value::Object(extra) };
Ok((entry, extra))
})
.await
}
#[derive(Deserialize)]
struct TransitionReq {
status: String,
assignee: Option<String>,
parent_task: Option<String>,
blocked_reason: Option<String>,
}
async fn transition_task(
State(st): St,
Path(key): Path<String>,
Json(r): Json<TransitionReq>,
) -> Reply {
if let Some(resp) = bad_key(&key) {
return resp;
}
let status = r.status.trim().to_string();
if model::TASK_TERMINAL_STATUSES.contains(&status.as_str()) {
return (
StatusCode::BAD_REQUEST,
Json(json!({"error": format!(
"'{status}' closes a task and needs an outcome — use `kyb done {key}` (POST /tasks/{key}/resolve) with a resolution; a transition only moves between {}",
model::TASK_LIVE_STATUSES.join("|")
)})),
);
}
if !model::TASK_LIVE_STATUSES.contains(&status.as_str()) {
return (
StatusCode::BAD_REQUEST,
Json(json!({"error": format!(
"status must be one of: {}", model::TASK_LIVE_STATUSES.join("|")
)})),
);
}
locked_write(&st, move |st| {
let Some(mut e) = stored_version(st, &key) else {
return Err((
StatusCode::NOT_FOUND,
Json(json!({"error": format!("no entry '{key}'")})),
));
};
if !e.is_task() {
return Err((
StatusCode::BAD_REQUEST,
Json(json!({"error": format!("'{key}' is not a task")})),
));
}
e.status = status;
if let Some(assignee) = r.assignee {
e.assignee = assignee.trim().to_string();
}
if let Some(parent) = r.parent_task {
e.parent_task = parent.trim().to_string();
}
if e.status == model::STATUS_BLOCKED {
if let Some(reason) = r.blocked_reason {
e.blocked_reason = reason;
}
} else {
e.blocked_reason.clear();
}
let mut extra = serde_json::Map::new();
extra.insert("status".into(), json!(e.status));
extra.insert("assignee".into(), json!(e.assignee));
if let Some(parent) = unknown_parent(st, &e) {
extra.insert("unknown_parent".into(), json!(parent));
}
Ok((e, Value::Object(extra)))
})
.await
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct IncidentsQ {
status: Option<String>,
service: Option<String>,
priority: Option<String>,
assignee: Option<String>,
parent_task: Option<String>,
followups: Option<String>,
all: Option<String>,
limit: Option<usize>,
}
fn open_followups_of(body: &str) -> usize {
body.lines().filter(|l| l.trim_start().starts_with("- [ ]")).count()
}
fn list_kind(
st: &AppState,
kind: &str,
status_order: &[&str],
q: &IncidentsQ,
) -> Result<Vec<(index::Hit, bool)>, Reply> {
let status = q.status.as_deref().filter(|s| !s.trim().is_empty());
let service = q.service.as_deref().filter(|s| !s.trim().is_empty());
let priority = q.priority.as_deref().filter(|s| !s.trim().is_empty());
let assignee = q.assignee.as_deref().map(str::trim).filter(|s| !s.is_empty());
let parent = q.parent_task.as_deref().map(str::trim).filter(|s| !s.is_empty());
let only_open_followups = q.followups.as_deref() == Some("open");
let all = matches!(q.all.as_deref(), Some("true" | "1" | "yes"));
let opts = index::SearchOpts {
limit: 500,
kind: Some(kind.to_string()),
status: status.map(String::from),
service: service.map(String::from),
priority: priority.map(String::from),
assignee: assignee.map(String::from),
parent_task: parent.map(String::from),
..Default::default()
};
let mut hits = match st.index.search("", &opts) {
Err(e) => return Err(err500(e)),
Ok(h) => h,
};
if only_open_followups {
hits.retain(|h| open_followups_of(&h.body) > 0);
}
let mut rows: Vec<(index::Hit, bool)> = hits
.into_iter()
.map(|h| {
let archived = is_archived(st, &h.key);
(h, archived)
})
.collect();
if !all && status.is_none() && !only_open_followups {
rows.retain(|(_, archived)| !archived);
}
let rank = |s: &str| status_order.iter().position(|x| *x == s).unwrap_or(9);
rows.sort_by(|(a, _), (b, _)| {
rank(&a.status)
.cmp(&rank(&b.status))
.then(b.committed_at.cmp(&a.committed_at))
.then(b.updated_at.cmp(&a.updated_at))
.then(a.key.cmp(&b.key))
});
rows.truncate(q.limit.unwrap_or(50).min(1000));
Ok(rows)
}
fn is_archived(st: &AppState, key: &str) -> bool {
!matches!(st.store.get(key), Ok(Some(_)))
}
async fn list_incidents(State(st): St, Q(q): Q<IncidentsQ>) -> Reply {
let rows = match list_kind(&st, model::KIND_INCIDENT, &model::STATUSES, &q) {
Err(r) => return r,
Ok(h) => h,
};
let rows: Vec<Value> = rows
.iter()
.map(|(h, archived)| {
json!({
"key": h.key, "title": h.title, "service": h.service, "hosts": h.hosts,
"severity": h.severity, "status": h.status, "knowledge": h.knowledge,
"resolution": h.resolution, "detection": h.detection, "affected": h.affected,
"started_at": h.started_at, "detected_at": h.detected_at,
"mitigated_at": h.mitigated_at, "resolved_at": h.resolved_at,
"open_followups": open_followups_of(&h.body),
"tags": h.tags, "updated_at": h.updated_at,
"archived": archived,
})
})
.collect();
(StatusCode::OK, Json(json!({"count": rows.len(), "incidents": rows})))
}
async fn list_tasks(State(st): St, Q(q): Q<IncidentsQ>) -> Reply {
let rows = match list_kind(&st, model::KIND_TASK, &model::TASK_STATUSES, &q) {
Err(r) => return r,
Ok(h) => h,
};
let rows: Vec<Value> = rows
.iter()
.map(|(h, archived)| {
json!({
"key": h.key, "title": h.title, "status": h.status,
"priority": h.priority, "blocked_reason": h.blocked_reason,
"assignee": h.assignee, "parent_task": h.parent_task,
"knowledge": h.knowledge, "resolution": h.resolution,
"resolved_at": h.resolved_at,
"open_followups": open_followups_of(&h.body),
"tags": h.tags, "updated_at": h.updated_at,
"archived": archived,
})
})
.collect();
(StatusCode::OK, Json(json!({"count": rows.len(), "tasks": rows})))
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct GetQ {
at: Option<String>,
}
fn parse_as_of(raw: &str, st: &AppState) -> Option<i64> {
parse_as_of_bound(raw, st, true)
}
fn parse_as_of_bound(raw: &str, st: &AppState, upper: bool) -> Option<i64> {
if let Ok(t) = chrono::DateTime::parse_from_rfc3339(raw) {
return Some(t.timestamp());
}
if let Ok(d) = chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d") {
let t = if upper { d.and_hms_opt(23, 59, 59) } else { d.and_hms_opt(0, 0, 0) };
return t.map(|dt| dt.and_utc().timestamp());
}
st.store.rev_time(raw).ok().flatten()
}
fn bad_key(key: &str) -> Option<Reply> {
if model::is_valid_key(key) {
None
} else {
Some((StatusCode::BAD_REQUEST, Json(json!({"error": "invalid key (slug [a-z0-9-])"}))))
}
}
fn entry_json(e: &model::Entry, archived: bool) -> Value {
let mut out = json!({
"key": e.key, "title": e.title, "kind": e.kind, "tags": e.tags, "refs": e.refs,
"updated_at": e.updated_at, "body": e.body,
});
let obj = out.as_object_mut().expect("out is an object");
if e.is_incident() {
obj.insert("service".into(), json!(e.service));
obj.insert("hosts".into(), json!(e.hosts));
obj.insert("severity".into(), json!(e.severity));
obj.insert("detection".into(), json!(e.detection));
obj.insert("affected".into(), json!(e.affected));
obj.insert("started_at".into(), json!(e.started_at));
obj.insert("detected_at".into(), json!(e.detected_at));
obj.insert("mitigated_at".into(), json!(e.mitigated_at));
}
if e.is_task() {
obj.insert("priority".into(), json!(e.priority));
obj.insert("blocked_reason".into(), json!(e.blocked_reason));
obj.insert("assignee".into(), json!(e.assignee));
obj.insert("parent_task".into(), json!(e.parent_task));
}
if e.is_incident() || e.is_task() {
obj.insert("status".into(), json!(e.status));
obj.insert("knowledge".into(), json!(e.knowledge));
obj.insert("resolution".into(), json!(e.resolution));
obj.insert("resolved_at".into(), json!(e.resolved_at));
obj.insert("open_followups".into(), json!(e.open_followups()));
}
if archived {
obj.insert("archived".into(), json!(true));
}
out
}
async fn get_one(State(st): St, Path(key): Path<String>, Q(q): Q<GetQ>) -> Reply {
if let Some(r) = bad_key(&key) {
return r;
}
let res = match &q.at {
Some(rev) => st.store.get_at(&key, rev),
None => st.store.get(&key),
};
match res {
Err(e) => err500(e),
Ok(Some(e)) => (StatusCode::OK, Json(entry_json(&e, false))),
Ok(None) if q.at.is_none() => {
match st.archived_version(&key) {
Err(e) => err500(e),
Ok(Some(e)) if e.kind != model::KIND_KNOWLEDGE => {
(StatusCode::OK, Json(entry_json(&e, true)))
}
_ => (StatusCode::NOT_FOUND, Json(json!({"error": format!("no entry '{key}'")}))),
}
}
Ok(None) => {
(StatusCode::NOT_FOUND, Json(json!({"error": format!("no entry '{key}'")})))
}
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct DiffQ {
from: Option<String>,
to: Option<String>,
}
async fn diff(State(st): St, Path(key): Path<String>, Q(q): Q<DiffQ>) -> Reply {
if let Some(r) = bad_key(&key) {
return r;
}
let versions = match st.history_cached(&key) {
Err(e) => return err500(e),
Ok(v) if v.is_empty() => {
return (
StatusCode::NOT_FOUND,
Json(json!({"error": format!("no history for '{key}'")})),
)
}
Ok(v) => v,
};
let pick = |o: &Option<String>, fallback: Option<&str>| -> Option<String> {
o.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_string)
.or_else(|| fallback.map(str::to_string))
};
let to_rev = pick(&q.to, versions.first().map(|v| v.sha.as_str()));
let from_rev = pick(&q.from, versions.get(1).map(|v| v.sha.as_str()));
let (Some(from_rev), Some(to_rev)) = (from_rev, to_rev) else {
return (
StatusCode::BAD_REQUEST,
Json(json!({
"error": format!("'{key}' has only one version; pass ?from=<rev>&to=<rev> explicitly")
})),
);
};
let resolve_side = |rev: &str| -> Result<Option<(String, String, String, String, bool, model::Entry)>, anyhow::Error> {
let deduce_kind = || {
if key.starts_with(model::TASK_PREFIX) {
model::KIND_TASK.to_string()
} else if key.starts_with(model::INCIDENT_PREFIX) {
model::KIND_INCIDENT.to_string()
} else {
model::KIND_KNOWLEDGE.to_string()
}
};
if rev == "initial" || rev == "empty" {
let mut empty = model::Entry::default();
empty.key = key.clone();
empty.kind = deduce_kind();
return Ok(Some((
"initial".to_string(),
String::new(),
"Initial State".to_string(),
"Initial creation".to_string(),
false,
empty,
)));
}
let Some((sha, time, author, msg)) = st.store.commit_details(rev)? else {
return Ok(None);
};
let committed_at = iso_secs(time);
match st.store.get_at(&key, &sha)? {
Some(entry) => Ok(Some((sha, committed_at, author, msg, true, entry))),
None => {
let in_hist = versions.iter().any(|v| v.sha == sha || v.sha.starts_with(&sha) || sha.starts_with(&v.sha));
if in_hist {
let mut archived = model::Entry::default();
archived.key = key.clone();
archived.kind = deduce_kind();
archived.status = "archived".to_string();
archived.title = format!("(Archived: {key})");
Ok(Some((sha, committed_at, author, msg, false, archived)))
} else {
Ok(None)
}
}
}
};
let from_side = match resolve_side(&from_rev) {
Err(e) => return err500(e),
Ok(Some(s)) => s,
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(json!({"error": format!("'{key}' does not exist at revision '{from_rev}'")})),
);
}
};
let to_side = match resolve_side(&to_rev) {
Err(e) => return err500(e),
Ok(Some(s)) => s,
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(json!({"error": format!("'{key}' does not exist at revision '{to_rev}'")})),
);
}
};
let (from_sha, from_at, from_author, from_msg, from_exists, from_entry) = from_side;
let (to_sha, to_at, to_author, to_msg, to_exists, to_entry) = to_side;
let (fields, body) = model::diff_entries(&from_entry, &to_entry);
let changed = !fields.is_empty() || !body.added.is_empty() || !body.removed.is_empty();
(
StatusCode::OK,
Json(json!({
"key": key,
"from": {
"rev": from_sha,
"committed_at": from_at,
"author": from_author,
"message": from_msg,
"exists": from_exists,
},
"to": {
"rev": to_sha,
"committed_at": to_at,
"author": to_author,
"message": to_msg,
"exists": to_exists,
},
"changed": changed,
"fields": fields,
"body": body,
"from_entry": entry_json(&from_entry, !from_exists),
"to_entry": entry_json(&to_entry, !to_exists),
})),
)
}
fn iso_secs(secs: i64) -> String {
chrono::DateTime::from_timestamp(secs, 0).map(|t| t.to_rfc3339()).unwrap_or_default()
}
async fn history(State(st): St, Path(key): Path<String>) -> Reply {
if let Some(r) = bad_key(&key) {
return r;
}
match st.history_cached(&key) {
Err(e) => err500(e),
Ok(v) if v.is_empty() => {
(StatusCode::NOT_FOUND, Json(json!({"error": format!("no history for '{key}'")})))
}
Ok(v) => (StatusCode::OK, Json(json!({"key": key, "versions": v}))),
}
}
async fn related(State(st): St, Path(key): Path<String>) -> Reply {
if let Some(r) = bad_key(&key) {
return r;
}
match st.links() {
Err(e) => err500(e),
Ok(ix) => (StatusCode::OK, Json(ix.related(&key))),
}
}
async fn places(State(st): St) -> Reply {
match st.links() {
Err(e) => err500(e),
Ok(ix) => (StatusCode::OK, Json(ix.places())),
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ImpactQ {
service: Option<String>,
host: Option<String>,
}
async fn impact(State(st): St, Q(q): Q<ImpactQ>) -> Reply {
let (by_host, name) = match (&q.service, &q.host) {
(Some(s), None) if !s.trim().is_empty() => (false, s.clone()),
(None, Some(h)) if !h.trim().is_empty() => (true, h.clone()),
_ => return (StatusCode::BAD_REQUEST, Json(json!({"error": "pass exactly one of ?service= or ?host="}))),
};
match st.links() {
Err(e) => err500(e),
Ok(ix) => (StatusCode::OK, Json(ix.impact(by_host, &name))),
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SearchQ {
q: Option<String>,
tag: Option<String>,
history: Option<bool>,
as_of: Option<String>,
changed_between: Option<String>,
limit: Option<usize>,
sort: Option<String>,
semantic: Option<bool>,
kind: Option<String>,
status: Option<String>,
service: Option<String>,
priority: Option<String>,
assignee: Option<String>,
parent_task: Option<String>,
}
async fn search(State(st): St, Q(p): Q<SearchQ>) -> Reply {
let tags: Vec<String> = p
.tag
.map(|t| t.split(',').map(|s| s.trim().to_string()).filter(|s| !s.is_empty()).collect())
.unwrap_or_default();
let q = p.q.as_deref().unwrap_or("");
let limit = p.limit.unwrap_or(10).min(100);
let sort = p.sort.as_deref().filter(|s| !s.trim().is_empty());
let recent = sort == Some("recent") || (q.trim().is_empty() && sort.is_none());
let history = p.history.unwrap_or(false);
let as_of = match p.as_of.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
None => None,
Some(raw) => match parse_as_of(raw, &st) {
Some(t) => Some(t),
None => {
return (
StatusCode::BAD_REQUEST,
Json(json!({"error": "as_of: expected an RFC3339 timestamp, a YYYY-MM-DD date, or a git revision that resolves"})),
)
}
},
};
let window = match p.changed_between.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
None => None,
Some(raw) => {
let Some((a, b)) = raw.split_once(',') else {
return (
StatusCode::BAD_REQUEST,
Json(json!({"error": "changed_between: expected <start>,<end>"})),
);
};
match (parse_as_of_bound(a.trim(), &st, false), parse_as_of_bound(b.trim(), &st, true)) {
(Some(lo), Some(hi)) if lo <= hi => Some((lo, hi)),
(Some(_), Some(_)) => {
return (
StatusCode::BAD_REQUEST,
Json(json!({"error": "changed_between: start is after end"})),
)
}
_ => {
return (
StatusCode::BAD_REQUEST,
Json(json!({"error": "changed_between: each side must be an RFC3339 timestamp, a YYYY-MM-DD date, or a git revision that resolves"})),
)
}
}
}
};
if as_of.is_some() && window.is_some() {
return (
StatusCode::BAD_REQUEST,
Json(json!({"error": "as_of and changed_between ask different questions; pass one"})),
);
}
let want_semantic = !recent
&& !history
&& as_of.is_none()
&& window.is_none()
&& !q.trim().is_empty()
&& st.semantic.is_some()
&& p.semantic != Some(false);
let norm = |o: &Option<String>| o.clone().filter(|s| !s.trim().is_empty());
let opts = index::SearchOpts {
tags: tags.clone(),
history,
as_of,
changed_between: window,
limit: if want_semantic { limit.max(24) } else { limit },
recent,
kind: norm(&p.kind),
status: norm(&p.status),
service: norm(&p.service),
priority: norm(&p.priority),
assignee: norm(&p.assignee),
parent_task: norm(&p.parent_task),
};
let mut hits = match st.index.search(q, &opts) {
Err(e) => return err500(e),
Ok(h) => h,
};
let mut semantic_used = false;
if want_semantic {
semantic_used = hybrid(&st, q, &opts, limit, &mut hits).await;
}
hits.truncate(limit);
let count = hits.len();
(StatusCode::OK, Json(json!({"count": count, "semantic": semantic_used, "hits": hits})))
}
async fn hybrid(
st: &Arc<AppState>,
q: &str,
opts: &index::SearchOpts,
limit: usize,
hits: &mut Vec<index::Hit>,
) -> bool {
let Some(sem) = st.semantic.as_ref() else { return false };
let scored = match sem.search(q, limit.max(24)).await {
Ok(s) => s,
Err(e) => {
eprintln!("kyb: semantic search skipped: {e:#}");
return false;
}
};
let sims: std::collections::HashMap<&str, f32> =
scored.iter().map(|(k, s)| (k.as_str(), *s)).collect();
let lexical_keys: Vec<String> = hits.iter().map(|h| h.key.clone()).collect();
let mut by_key: std::collections::HashMap<String, index::Hit> =
hits.drain(..).map(|h| (h.key.clone(), h)).collect();
for key in embed::fuse_lists(&lexical_keys, &scored, 0.6) {
let hit = match by_key.remove(&key) {
Some(h) => Some(h),
None => match st.index.get_live(&key) {
Ok(Some(h)) => {
let keeps = opts
.tags
.iter()
.all(|t| h.tags.iter().any(|x| x.eq_ignore_ascii_case(t)))
&& opts.kind.as_deref().is_none_or(|k| h.kind == k)
&& opts.status.as_deref().is_none_or(|s| h.status == s)
&& opts.priority.as_deref().is_none_or(|p| h.priority == p)
&& opts.assignee.as_deref().is_none_or(|a| h.assignee == a)
&& opts.parent_task.as_deref().is_none_or(|p| h.parent_task == p)
&& opts
.service
.as_deref()
.is_none_or(|s| h.service.eq_ignore_ascii_case(s));
keeps.then_some(h)
}
_ => None,
},
};
if let Some(mut h) = hit {
if let Some(s) = sims.get(h.key.as_str()) {
h.score = *s;
}
hits.push(h);
if hits.len() >= limit {
break;
}
}
}
true
}
async fn tags(State(st): St) -> Reply {
let entries = match st.store.list_head() {
Err(e) => return err500(e),
Ok(v) => v,
};
let mut counts: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
for e in &entries {
for t in &e.tags {
*counts.entry(t.to_lowercase()).or_default() += 1;
}
}
let mut rows: Vec<(String, usize)> = counts.into_iter().collect();
rows.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(&b.0)));
let tags: Vec<Value> = rows.into_iter().map(|(t, c)| json!({"tag": t, "count": c})).collect();
(StatusCode::OK, Json(json!({"count": tags.len(), "tags": tags})))
}
async fn remove(State(st): St, Path(key): Path<String>) -> Reply {
if let Some(r) = bad_key(&key) {
return r;
}
let mut w = st.writer.lock().await;
let entry = match st.store.get(&key) {
Err(e) => return err500(e),
Ok(None) => {
return (StatusCode::NOT_FOUND, Json(json!({"error": format!("no entry '{key}'")})))
}
Ok(Some(e)) => e,
};
if entry.kind == model::KIND_KNOWLEDGE && auth::role() < auth::Role::Admin {
return (StatusCode::FORBIDDEN, Json(json!({"error": "retracting a knowledge entry needs the admin role", "needs": "admin"})));
}
st.note_write(&key);
let reply = remove_committed(&st, &mut w, &key, &entry).await;
st.note_write(&key);
reply
}
async fn remove_committed(
st: &Arc<AppState>,
w: &mut tokio::sync::MutexGuard<'_, IndexWriter>,
key: &str,
entry: &model::Entry,
) -> Reply {
if entry.kind == model::KIND_KNOWLEDGE {
match st.store.delete(key) {
Err(e) => err500(e),
Ok(None) => {
(StatusCode::NOT_FOUND, Json(json!({"error": format!("no entry '{key}'")})))
}
Ok(Some(sha)) => {
st.index.delete_head(w, key);
let at = st
.store
.rev_time(&sha)
.ok()
.flatten()
.unwrap_or_else(|| chrono::Utc::now().timestamp());
st.index.retract(key, at);
if let Err(e) = st.index.commit_and_reload(w) {
return err500(
e.context("git committed but the index was not updated — run POST /reindex"),
);
}
if let Some(sem) = st.semantic.as_ref() {
sem.invalidate(key).await;
}
(StatusCode::OK, Json(json!({"key": key, "deleted": true, "sha": sha})))
}
}
} else {
match st.store.archive(key) {
Err(e) => err500(e),
Ok(None) => {
(StatusCode::NOT_FOUND, Json(json!({"error": format!("no entry '{key}'")})))
}
Ok(Some(sha)) => {
st.note_archived(key);
(StatusCode::OK, Json(json!({"key": key, "archived": true, "sha": sha})))
}
}
}
}
async fn reindex(State(st): St) -> Reply {
let mut w = st.writer.lock().await;
let res = st.index.reindex(&mut w, &st.store);
let vector_job = match (&res, st.semantic.as_ref()) {
(Ok(_), Some(sem)) => match vector_docs(&st) {
Some(docs) => Some(sem.begin_rebuild(docs).await),
None => None,
},
_ => None,
};
drop(w);
match res {
Err(e) => err500(e),
Ok((heads, hist)) => {
if let Some(job) = vector_job {
finish_vector_rebuild(&st, job).await;
}
(StatusCode::OK, Json(json!({"ok": true, "head_docs": heads, "history_docs": hist})))
}
}
}
const CAPABILITIES: [&str; 3] = ["as_of", "changed_between", "diff"];
async fn healthz(State(st): St) -> Reply {
let heads = st.store.list_head().unwrap_or_default();
let open_incidents =
heads.iter().filter(|e| e.is_incident() && e.status == "open").count();
let open_tasks = heads.iter().filter(|e| e.is_live_task()).count();
let index_docs = st.index.reader.searcher().num_docs();
let last = st.store.head_info().ok().flatten();
(
StatusCode::OK,
Json(json!({
"ok": true,
"entries": heads.len(),
"open_incidents": open_incidents,
"open_tasks": open_tasks,
"index_docs": index_docs,
"last_commit": last.map(|(sha, time)| json!({"sha": sha, "time": time})),
"version": env!("CARGO_PKG_VERSION"),
"capabilities": CAPABILITIES,
})),
)
}
#[cfg(test)]
mod api_tests {
use super::*;
use axum::body::Body;
use axum::http::Request;
use http_body_util::BodyExt;
use rstest::rstest;
use tower::util::ServiceExt;
pub(super) async fn call(app: &Router, method: &str, uri: &str, body: Option<Value>) -> (StatusCode, Value) {
let b = Request::builder().method(method).uri(uri);
let req = match body {
Some(v) => b
.header("content-type", "application/json")
.body(Body::from(v.to_string()))
.unwrap(),
None => b.body(Body::empty()).unwrap(),
};
let resp = app.clone().oneshot(req).await.unwrap();
let status = resp.status();
let bytes = resp.into_body().collect().await.unwrap().to_bytes();
let val: Value = serde_json::from_slice(&bytes).unwrap_or(Value::Null);
(status, val)
}
pub(super) fn upsert_body(key: &str, body: &str) -> Value {
json!({"key": key, "title": "NATS стримы", "body": body, "tags": ["nats"]})
}
fn app_with_state() -> (Router, Arc<AppState>, tempfile::TempDir, tempfile::TempDir) {
let data = tempfile::tempdir().unwrap();
let idx = tempfile::tempdir().unwrap();
let cfg = config::Config {
data_dir: data.path().to_path_buf(),
index_dir: idx.path().to_path_buf(),
audit_path: idx.path().join("audit.jsonl"),
model_dir: idx.path().join("no-model"),
addr: String::new(),
};
let state = build_state_with(&cfg, auth::Auth::off()).unwrap();
(build_app(state.clone()), state, data, idx)
}
fn app_with_auth(mode: auth::Mode, anon: Option<auth::Role>) -> (Router, [String; 3], tempfile::TempDir, tempfile::TempDir) {
let data = tempfile::tempdir().unwrap();
let idx = tempfile::tempdir().unwrap();
let cfg = config::Config {
data_dir: data.path().to_path_buf(),
index_dir: idx.path().to_path_buf(),
audit_path: idx.path().join("audit.jsonl"),
model_dir: idx.path().join("no-model"),
addr: String::new(),
};
let mut book = auth::Book::default();
let read = book.add("reader", "Rita Reader", "", auth::Role::Read, "").unwrap();
let write = book.add("agent-w", "Agent W", "w@fleet", auth::Role::Write, "").unwrap();
let admin = book.add("owner", "The Owner", "o@fleet", auth::Role::Admin, "").unwrap();
let book_path = idx.path().join("auth.json");
book.save(&book_path).unwrap();
let state = build_state_with(&cfg, auth::Auth::new(mode, anon, book_path)).unwrap();
(build_app(state), [read, write, admin], data, idx)
}
async fn call_as(app: &Router, token: Option<&str>, method: &str, uri: &str, body: Option<Value>) -> (StatusCode, Value) {
let mut b = Request::builder().method(method).uri(uri);
if let Some(t) = token {
b = b.header("authorization", format!("Bearer {t}"));
}
let req = match body {
Some(v) => b.header("content-type", "application/json").body(Body::from(v.to_string())).unwrap(),
None => b.body(Body::empty()).unwrap(),
};
let resp = app.clone().oneshot(req).await.unwrap();
let status = resp.status();
let bytes = resp.into_body().collect().await.unwrap().to_bytes();
(status, serde_json::from_slice(&bytes).unwrap_or(Value::Null))
}
#[tokio::test]
async fn required_auth_holds_every_route_to_a_role_and_signs_commits() {
let (app, [read, write, admin], _data, idx) = app_with_auth(auth::Mode::Required, None);
let (r, w, a) = (Some(read.as_str()), Some(write.as_str()), Some(admin.as_str()));
assert_eq!(call_as(&app, None, "GET", "/search?q=x", None).await.0, StatusCode::UNAUTHORIZED);
assert_eq!(call_as(&app, None, "POST", "/knowledge", Some(upsert_body("n", "b"))).await.0, StatusCode::UNAUTHORIZED);
assert_eq!(call_as(&app, None, "GET", "/healthz", None).await.0, StatusCode::OK);
let (st, me) = call_as(&app, None, "GET", "/whoami", None).await;
assert_eq!((st, me["auth"].clone(), me["role"].clone(), me["actor"].clone()), (StatusCode::OK, json!("required"), json!("read"), Value::Null));
let (st, e) = call_as(&app, Some("kyb_never-issued"), "GET", "/search?q=x", None).await;
assert_eq!(st, StatusCode::UNAUTHORIZED);
assert!(e["error"].as_str().unwrap().contains("not known"));
assert_eq!(call_as(&app, r, "GET", "/search?q=x", None).await.0, StatusCode::OK);
let (st, e) = call_as(&app, r, "POST", "/knowledge", Some(upsert_body("note", "body"))).await;
assert_eq!((st, e["needs"].clone(), e["role"].clone()), (StatusCode::FORBIDDEN, json!("write"), json!("read")));
let (_, me) = call_as(&app, r, "GET", "/whoami", None).await;
assert_eq!((me["role"].clone(), me["actor"]["id"].clone(), me["actor"]["name"].clone()), (json!("read"), json!("reader"), json!("Rita Reader")));
assert_eq!(call_as(&app, w, "POST", "/knowledge", Some(upsert_body("note", "body"))).await.0, StatusCode::OK);
let (_, h) = call_as(&app, r, "GET", "/knowledge/note/history", None).await;
assert_eq!(h["versions"][0]["author"], "Agent W <w@fleet>");
assert_eq!(call_as(&app, w, "POST", "/incidents", Some(json!({"key": "inc-a", "title": "A", "service": "s", "severity": "low", "body": "b"}))).await.0, StatusCode::OK);
assert_eq!(call_as(&app, w, "POST", "/incidents/inc-a/resolve", Some(json!({"resolution": "ok"}))).await.0, StatusCode::OK);
assert_eq!(call_as(&app, w, "POST", "/incidents", Some(json!({"key": "inc-b", "title": "B", "service": "s", "severity": "low", "body": "b"}))).await.0, StatusCode::OK);
assert_eq!(call_as(&app, w, "DELETE", "/knowledge/inc-b", None).await.0, StatusCode::OK);
let (st, e) = call_as(&app, w, "DELETE", "/knowledge/note", None).await;
assert_eq!((st, e["needs"].clone()), (StatusCode::FORBIDDEN, json!("admin")));
assert_eq!(call_as(&app, w, "POST", "/reindex", None).await.0, StatusCode::FORBIDDEN);
assert_eq!(call_as(&app, a, "POST", "/knowledge", Some(upsert_body("note", "body two"))).await.0, StatusCode::OK);
let (_, h) = call_as(&app, a, "GET", "/knowledge/note/history", None).await;
assert_eq!((h["versions"][0]["author"].clone(), h["versions"][1]["author"].clone()), (json!("The Owner <o@fleet>"), json!("Agent W <w@fleet>")));
assert_eq!(call_as(&app, a, "POST", "/reindex", None).await.0, StatusCode::OK);
assert_eq!(call_as(&app, a, "DELETE", "/knowledge/note", None).await.0, StatusCode::OK);
let mcp = |token: Option<&str>, name: &str, args: Value| {
let app = app.clone();
let token = token.map(str::to_string);
let payload = json!({"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": name, "arguments": args}});
async move { call_as(&app, token.as_deref(), "POST", "/mcp", Some(payload)).await.1 }
};
let add = json!({"key": "via-mcp", "title": "T", "body": "b"});
let refused = mcp(r, "kyb_add", add.clone()).await;
assert_eq!(refused["result"]["isError"], json!(true));
assert!(refused["result"]["content"][0]["text"].as_str().unwrap().contains("403"), "{refused}");
let nameless = mcp(None, "kyb_get", json!({"key": "via-mcp"})).await;
assert!(nameless["result"]["content"][0]["text"].as_str().unwrap().contains("401"), "{nameless}");
assert_ne!(mcp(w, "kyb_add", add).await["result"]["isError"], json!(true));
let (_, h) = call_as(&app, r, "GET", "/knowledge/via-mcp/history", None).await;
assert_eq!(h["versions"][0]["author"], "Agent W <w@fleet>");
assert_eq!(call_as(&app, r, "GET", "/api/audit", None).await.0, StatusCode::FORBIDDEN);
assert_eq!(call_as(&app, w, "GET", "/api/audit", None).await.0, StatusCode::FORBIDDEN);
assert_eq!(call_as(&app, a, "GET", "/api/audit", None).await.0, StatusCode::OK);
assert_eq!(call_as(&app, r, "GET", "/api/activity", None).await.0, StatusCode::OK);
let log = std::fs::read_to_string(idx.path().join("audit.jsonl")).unwrap();
let actors: Vec<String> = log.lines().filter_map(|l| serde_json::from_str::<Value>(l).ok()).map(|v| v["actor"].as_str().unwrap_or("?").to_string()).collect();
for who in ["reader", "agent-w", "owner", "refused"] {
assert!(actors.iter().any(|a| a == who), "no audit line for {who}: {actors:?}");
}
}
#[tokio::test]
async fn compat_keeps_the_nameless_working_and_a_demo_reads_without_a_token() {
let (app, [read, write, _], _data, _idx) = app_with_auth(auth::Mode::Compat, None);
assert_eq!(call_as(&app, None, "POST", "/knowledge", Some(upsert_body("old-client", "b"))).await.0, StatusCode::OK);
let (_, h) = call_as(&app, None, "GET", "/knowledge/old-client/history", None).await;
assert_eq!(h["versions"][0]["author"], "");
let (_, me) = call_as(&app, None, "GET", "/whoami", None).await;
assert_eq!((me["auth"].clone(), me["role"].clone()), (json!("compat"), json!("admin")));
assert_eq!(call_as(&app, Some(&write), "POST", "/knowledge", Some(upsert_body("new-client", "b"))).await.0, StatusCode::OK);
assert_eq!(call_as(&app, Some(&read), "POST", "/knowledge", Some(upsert_body("x", "b"))).await.0, StatusCode::FORBIDDEN);
let (demo, [_, write, _], _d, _i) = app_with_auth(auth::Mode::Required, Some(auth::Role::Read));
assert_eq!(call_as(&demo, None, "GET", "/search?q=x", None).await.0, StatusCode::OK);
assert_eq!(call_as(&demo, None, "GET", "/api/audit", None).await.0, StatusCode::FORBIDDEN);
assert_eq!(call_as(&demo, None, "POST", "/knowledge", Some(upsert_body("x", "b"))).await.0, StatusCode::FORBIDDEN);
assert_eq!(call_as(&demo, Some(&write), "POST", "/knowledge", Some(upsert_body("x", "b"))).await.0, StatusCode::OK);
}
pub(super) fn app_with_tmp() -> (Router, tempfile::TempDir, tempfile::TempDir) {
let (app, _state, data, idx) = app_with_state();
(app, data, idx)
}
#[tokio::test]
async fn api_full_flow() {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["entries"], 0);
let (st, v) = call(&app, "POST", "/knowledge", Some(upsert_body("nats-streams", "Primary version about streams."))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert_eq!(v["action"], "created");
let sha1 = v["sha"].as_str().unwrap().to_string();
assert_eq!(sha1.len(), 40);
let (_, v) = call(&app, "POST", "/knowledge", Some(upsert_body("nats-streams", "Primary version about streams."))).await;
assert_eq!(v["changed"], false);
let (_, v) = call(&app, "POST", "/knowledge", Some(upsert_body("nats-streams", "Secondary version: the rule moved."))).await;
assert_eq!(v["action"], "updated");
let sha2 = v["sha"].as_str().unwrap().to_string();
assert_ne!(sha1, sha2);
let (st, v) = call(&app, "GET", "/knowledge/nats-streams", None).await;
assert_eq!(st, StatusCode::OK);
assert!(v["body"].as_str().unwrap().contains("Secondary"));
let (_, v) = call(&app, "GET", &format!("/knowledge/nats-streams?at={sha1}"), None).await;
assert!(v["body"].as_str().unwrap().contains("Primary"));
let (_, v) = call(&app, "GET", "/knowledge/nats-streams/history", None).await;
assert_eq!(v["versions"].as_array().unwrap().len(), 2);
let (_, v) = call(&app, "GET", "/search?q=%D1%81%D1%82%D1%80%D0%B8%D0%BC%D0%B0%D1%85", None).await;
assert_eq!(v["count"], 1);
assert_eq!(v["hits"][0]["key"], "nats-streams");
assert_eq!(v["hits"][0]["is_head"], true);
let q_old = "/search?q=Primary";
let (_, v) = call(&app, "GET", q_old, None).await;
assert_eq!(v["count"], 0);
let (_, v) = call(&app, "GET", &format!("{q_old}&history=true"), None).await;
assert!(v["count"].as_u64().unwrap() >= 1);
assert_eq!(v["hits"][0]["is_head"], false);
assert_eq!(v["hits"][0]["sha"], sha1);
let (_, v) = call(&app, "GET", "/search?q=nats&tag=nats", None).await;
assert_eq!(v["count"], 1);
let (_, v) = call(&app, "GET", "/search?q=nats&tag=missing", None).await;
assert_eq!(v["count"], 0);
let (_, v) = call(&app, "DELETE", "/knowledge/nats-streams", None).await;
assert_eq!(v["deleted"], true);
let (st, _) = call(&app, "GET", "/knowledge/nats-streams", None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
let (_, v) = call(&app, "GET", "/search?q=nats", None).await;
assert_eq!(v["count"], 0);
let (_, v) = call(&app, "GET", "/search?q=nats&history=true", None).await;
assert!(v["count"].as_u64().unwrap() >= 2);
let (_, v) = call(&app, "POST", "/reindex", None).await;
assert_eq!(v["ok"], true);
assert_eq!(v["head_docs"], 0);
assert_eq!(v["history_docs"], 2);
let (st, _) = call(&app, "POST", "/knowledge", Some(json!({"key": "Bad Key", "title": "t", "body": "x"}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST);
let (st, v) = call(&app, "POST", "/knowledge", Some(json!({"key": "leak", "title": "t", "body": "token: ghp_abcdefghijklmnopqrstuvwxyz123456"}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST);
assert!(v["error"].as_str().unwrap().contains("secret"));
let (st, _) = call(&app, "GET", "/knowledge/nope", None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
let (st, _) = call(&app, "GET", "/knowledge/nope/history", None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
}
#[tokio::test]
async fn relations_follow_the_repository() {
let (app, state, _data, _idx) = app_with_state();
let state_of = |_: &Router| state.clone();
call(&app, "POST", "/knowledge", Some(upsert_body("redis-runbook", "How to restart redis."))).await;
let (st, v) = call(&app, "GET", "/knowledge/redis-runbook/related", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!((v["known"].clone(), v["incoming"].as_array().unwrap().len()), (json!(true), 0));
let (st, _) = call(&app, "POST", "/incidents", Some(json!({
"key": "inc-redis-oom", "title": "Redis OOM", "service": "Redis", "hosts": ["cache-01"],
"severity": "high", "knowledge": ["redis-runbook"], "body": "See [[redis-runbook]]."
}))).await;
assert_eq!(st, StatusCode::OK);
let (_, v) = call(&app, "GET", "/knowledge/redis-runbook/related", None).await;
assert_eq!(v["incoming"][0]["key"], "inc-redis-oom");
assert_eq!((v["incoming"][0]["via"].clone(), v["incoming"][0]["live"].clone()), (json!("knowledge"), json!(true)));
let (st, p) = call(&app, "GET", "/places", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!((p["services"][0]["name"].clone(), p["services"][0]["open"].clone(), p["hosts"][0]["name"].clone()), (json!("redis"), json!(1), json!("cache-01")));
let (st, i) = call(&app, "GET", "/impact?service=redis", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!((i["open"].clone(), i["incidents"][0]["key"].clone(), i["runbooks"][0]["key"].clone()), (json!(1), json!("inc-redis-oom"), json!("redis-runbook")));
assert_eq!(i["runbooks"][0]["because"], json!(["inc-redis-oom"]));
let (_, h) = call(&app, "GET", "/impact?host=cache-01", None).await;
assert_eq!((h["kind"].clone(), h["incidents"].as_array().unwrap().len()), (json!("host"), 1));
let (st, _) = call(&app, "POST", "/incidents/inc-redis-oom/resolve", Some(json!({"resolution": "raised maxmemory"}))).await;
assert_eq!(st, StatusCode::OK);
let (_, v) = call(&app, "GET", "/knowledge/redis-runbook/related", None).await;
assert_eq!((v["incoming"][0]["live"].clone(), v["incoming"][0]["archived"].clone()), (json!(false), json!(true)));
let (_, p) = call(&app, "GET", "/places", None).await;
assert_eq!((p["services"][0]["open"].clone(), p["services"][0]["total"].clone()), (json!(0), json!(1)));
call(&app, "POST", "/incidents", Some(json!({"key": "inc-two", "title": "Two", "service": "redis", "severity": "low", "knowledge": ["redis-runbook"], "body": "b"}))).await;
call(&app, "GET", "/places", None).await;
call(&app, "POST", "/incidents/inc-two/resolve", Some(json!({"resolution": "ok"}))).await;
call(&app, "POST", "/incidents", Some(json!({"key": "inc-flash", "title": "Flash", "service": "redis", "severity": "low", "knowledge": ["redis-runbook"], "body": "b"}))).await;
call(&app, "POST", "/incidents/inc-flash/resolve", Some(json!({"resolution": "ok"}))).await;
let (_, v) = call(&app, "GET", "/knowledge/redis-runbook/related", None).await;
let incoming: Vec<(String, bool)> = v["incoming"].as_array().unwrap().iter().map(|r| (r["key"].as_str().unwrap().to_string(), r["archived"] == json!(true))).collect();
assert!(incoming.contains(&("inc-two".to_string(), true)) && incoming.contains(&("inc-redis-oom".to_string(), true)) && incoming.contains(&("inc-flash".to_string(), true)), "{incoming:?}");
call(&app, "POST", "/knowledge", Some(upsert_body("pointer", "See [[redis-runbook]]."))).await;
let (_, v) = call(&app, "GET", "/knowledge/redis-runbook/related", None).await;
assert!(v["incoming"].as_array().unwrap().iter().any(|r| r["key"] == "pointer"));
call(&app, "DELETE", "/knowledge/pointer", None).await;
let (_, v) = call(&app, "GET", "/knowledge/redis-runbook/related", None).await;
assert!(!v["incoming"].as_array().unwrap().iter().any(|r| r["key"] == "pointer"), "a retracted note keeps no edges");
call(&app, "POST", "/incidents", Some(json!({"key": "inc-two", "title": "Two again", "service": "redis", "severity": "high", "knowledge": ["redis-runbook"], "body": "b"}))).await;
let (_, v) = call(&app, "GET", "/knowledge/redis-runbook/related", None).await;
let again = v["incoming"].as_array().unwrap().iter().find(|r| r["key"] == "inc-two").unwrap().clone();
assert_eq!((again["archived"].clone(), again["live"].clone(), again["title"].clone()), (json!(false), json!(true), json!("Two again")));
let st = state_of(&app);
call(&app, "POST", "/incidents", Some(json!({"key": "inc-refile", "title": "R", "service": "redis", "severity": "low", "knowledge": ["redis-runbook"], "body": "b"}))).await;
call(&app, "POST", "/incidents/inc-refile/resolve", Some(json!({"resolution": "ok"}))).await;
call(&app, "POST", "/incidents", Some(json!({"key": "inc-refile", "title": "R again", "service": "redis", "severity": "high", "knowledge": ["redis-runbook"], "body": "b"}))).await;
let noted = |k: &str| st.archived_since.lock().unwrap().iter().any(|(_, key)| key == k);
assert!(noted("inc-refile"), "the archive was noted");
let (_, v) = call(&app, "GET", "/knowledge/redis-runbook/related", None).await;
let r = v["incoming"].as_array().unwrap().iter().find(|r| r["key"] == "inc-refile").cloned().unwrap();
assert_eq!((r["archived"].clone(), r["live"].clone(), r["title"].clone()), (json!(false), json!(true), json!("R again")));
assert!(!noted("inc-refile"), "the note is settled by the build that saw the key live");
st.note_archived("inc-pushed-later");
call(&app, "GET", "/places", None).await; assert_eq!(st.archived_since.lock().unwrap().len(), 1);
st.note_write("anything"); call(&app, "GET", "/places", None).await;
assert!(st.archived_since.lock().unwrap().is_empty(), "a note for a key nowhere in the tree is settled by the next build");
st.note_archived("inc-twice");
let snapshot = st.archived_since.lock().unwrap().clone(); st.note_archived("inc-twice"); st.settle_notes(&snapshot);
let left = st.archived_since.lock().unwrap().clone();
assert_eq!(left.len(), 1, "the newer note survives: {left:?}");
assert!(left[0].0 > snapshot[0].0 && left[0].1 == "inc-twice");
st.settle_notes(&left);
assert!(st.archived_since.lock().unwrap().is_empty());
for bad in ["/impact", "/impact?service=a&host=b", "/impact?service=%20", "/impact?host="] {
let (st, v) = call(&app, "GET", bad, None).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{bad}: {v}");
}
let (st, _) = call(&app, "GET", "/knowledge/Bad_Key/related", None).await;
assert_eq!(st, StatusCode::BAD_REQUEST);
let (st, v) = call(&app, "GET", "/knowledge/never-written/related", None).await;
assert_eq!((st, v["known"].clone()), (StatusCode::OK, json!(false)));
}
#[tokio::test]
async fn healthz_advertises_version_and_capabilities() {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["version"], env!("CARGO_PKG_VERSION"));
let caps: Vec<&str> =
v["capabilities"].as_array().unwrap().iter().map(|c| c.as_str().unwrap()).collect();
for want in ["as_of", "changed_between", "diff"] {
assert!(caps.contains(&want), "healthz must advertise {want}, got {caps:?}");
}
}
#[rstest]
#[case("/search?q=x&knid=incident", "knid")]
#[case("/search?q=x&zzz_nonsense=1", "zzz_nonsense")]
#[case("/search?q=x&as_off=2026-08-01", "as_off")]
#[case("/knowledge/demo?att=abc", "att")]
#[case("/knowledge/demo/diff?frm=a", "frm")]
#[case("/incidents?statuss=open", "statuss")]
#[case("/tasks?priorty=high", "priorty")]
#[tokio::test]
async fn unknown_query_parameters_are_refused(#[case] uri: &str, #[case] offender: &str) {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("demo", "body"))).await;
let (st, v) = call(&app, "GET", uri, None).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{uri} must be refused, got {v}");
let msg = v["error"].as_str().unwrap_or_default();
assert!(msg.contains(offender), "the error must name the parameter: {msg}");
}
#[rstest]
#[case("/search?q=x&kind=knowledge")]
#[case("/search?q=x&as_of=2999-01-01")]
#[case("/search?q=x&changed_between=2000-01-01,2999-01-01")]
#[case("/knowledge/demo")]
#[case("/incidents?status=open")]
#[case("/tasks?priority=high")]
#[tokio::test]
async fn known_query_parameters_still_pass(#[case] uri: &str) {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("demo", "body"))).await;
let (st, v) = call(&app, "GET", uri, None).await;
assert_eq!(st, StatusCode::OK, "{uri} must still work, got {v}");
}
#[tokio::test]
async fn a_retracted_key_is_flagged_when_it_comes_back() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("withdrawn", "the first take"))).await;
call(&app, "DELETE", "/knowledge/withdrawn", None).await;
assert_eq!(call(&app, "GET", "/knowledge/withdrawn", None).await.0, StatusCode::NOT_FOUND);
let (st, v) =
call(&app, "POST", "/knowledge", Some(upsert_body("withdrawn", "a second take"))).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["action"], "created", "the tree has forgotten it");
assert_eq!(v["revived"], true, "history has not, and says so");
assert!(v["hint"].as_str().unwrap().contains("retracted"), "{v}");
let (_, v) = call(&app, "POST", "/knowledge", Some(upsert_body("brand-new", "x"))).await;
assert!(v["revived"].is_null());
assert!(v["hint"].is_null());
}
#[tokio::test]
async fn a_twin_of_a_retracted_key_is_still_surfaced() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("rule-name-your-comparison-baseline", "x")))
.await;
call(&app, "DELETE", "/knowledge/rule-name-your-comparison-baseline", None).await;
let (_, v) =
call(&app, "POST", "/knowledge", Some(upsert_body("rule-name-your-comparison-base", "y")))
.await;
let similar: Vec<&str> =
v["similar"].as_array().map(|a| a.iter().filter_map(|x| x.as_str()).collect()).unwrap_or_default();
assert!(
similar.contains(&"rule-name-your-comparison-baseline"),
"a retracted near-twin must still be surfaced, got {v}"
);
}
#[tokio::test]
async fn diff_endpoint() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "the port is 8080"))).await;
let (st, v) = call(&app, "GET", "/knowledge/svc/diff", None).await;
assert_eq!(st, StatusCode::BAD_REQUEST);
assert!(v["error"].as_str().unwrap().contains("only one version"));
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "the port is 9090"))).await;
let (st, v) = call(&app, "GET", "/knowledge/svc/diff", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["changed"], true);
assert_eq!(v["body"]["removed"][0], "the port is 8080");
assert_eq!(v["body"]["added"][0], "the port is 9090");
let (_, h) = call(&app, "GET", "/knowledge/svc/history", None).await;
let newest = h["versions"][0]["sha"].as_str().unwrap().to_string();
let oldest = h["versions"][1]["sha"].as_str().unwrap().to_string();
let (st, v) =
call(&app, "GET", &format!("/knowledge/svc/diff?from={oldest}&to={newest}"), None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["body"]["added"][0], "the port is 9090");
let (_, v) =
call(&app, "GET", &format!("/knowledge/svc/diff?from={newest}&to={newest}"), None).await;
assert_eq!(v["changed"], false);
assert!(v["fields"].as_array().unwrap().is_empty());
let (_, v) =
call(&app, "GET", &format!("/knowledge/svc/diff?from={newest}&to={oldest}"), None).await;
assert_eq!(v["body"]["removed"][0], "the port is 9090");
assert_eq!(v["body"]["added"][0], "the port is 8080");
let (st, v) =
call(&app, "GET", &format!("/knowledge/svc/diff?from=initial&to={oldest}"), None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["changed"], true);
assert_eq!(v["from"]["exists"], false);
assert_eq!(v["to"]["exists"], true);
assert_eq!(v["body"]["added"][0], "the port is 8080");
assert!(v["to"]["author"].as_str().is_some());
assert!(v["to"]["message"].as_str().is_some());
assert_eq!(v["to_entry"]["key"], "svc");
call(&app, "POST", "/tasks", Some(json!({"key": "task-clean-logs", "title": "Clean logs", "body": "clear /tmp/logs"}))).await;
call(&app, "POST", "/tasks/task-clean-logs/resolve", Some(json!({"resolution": "done"}))).await;
let (st, v) = call(&app, "GET", "/knowledge/task-clean-logs/diff", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["changed"], true);
assert_eq!(v["to"]["exists"], false);
assert_eq!(v["to_entry"]["status"], "archived");
let (st, _) = call(&app, "GET", "/knowledge/svc/diff?from=zzz&to=zzz", None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
let (st, _) = call(&app, "GET", "/knowledge/nope/diff", None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
}
#[test]
fn attribution_trailers_round_trip_and_stay_on_one_line() {
let by = auth::By::new("claude", "sess-1", "kyb/ui", "cli");
let msg = auth::message_with_trailers("kyb: upsert x", Some(&by));
assert_eq!(msg, "kyb: upsert x\n\nKyb-Agent: claude\nKyb-Session: sess-1\nKyb-Workspace: kyb/ui\nKyb-Via: cli\n");
assert_eq!(auth::By::from_message(&msg), Some(by.clone()));
assert_eq!(auth::message_with_trailers("kyb: upsert x", None), "kyb: upsert x");
assert_eq!(auth::By::from_message("kyb: upsert x"), None);
let sly = auth::By::new("codex\nKyb-Agent: root", "", "", "cli");
assert_eq!(sly.agent, "codexKyb-Agent: root");
assert_eq!(auth::By::from_message(&auth::message_with_trailers("m", Some(&sly))).unwrap().agent, "codexKyb-Agent: root");
assert_eq!(auth::By::from_message("summary\n\nsome body\n\nKyb-Agent: antigravity\nKyb-Via: meta").unwrap().agent, "antigravity");
assert_eq!(auth::By::new("", "s", "", "").trailers(), "Kyb-Session: s\n");
assert!(auth::By::new("", "", "", "hook").is_empty(), "a via alone is nobody");
}
#[tokio::test]
async fn attribution_from_headers_hook_and_meta_lands_on_the_commit() {
let (app, _data, _idx) = app_with_tmp();
let req = Request::builder().method("POST").uri("/knowledge").header("content-type", "application/json")
.header("x-kyb-agent", "claude").header("x-kyb-session", "18970ebf").header("x-kyb-workspace", "knowyourbusiness/scripts").header("x-kyb-via", "cli")
.body(Body::from(upsert_body("by-cli", "written by the cli").to_string())).unwrap();
assert_eq!(app.clone().oneshot(req).await.unwrap().status(), StatusCode::OK);
let (_, h) = call(&app, "GET", "/knowledge/by-cli/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "claude", "session": "18970ebf", "workspace": "knowyourbusiness/scripts", "via": "cli"}));
let (_, act) = call(&app, "GET", "/api/activity?limit=5", None).await;
let ev = act["activity"].as_array().unwrap();
assert_eq!(ev.iter().find(|e| e["key"] == "by-cli").unwrap()["by"]["agent"], "claude");
let req = Request::builder().method("GET").uri("/whoami").header("x-kyb-agent", "codex").header("x-kyb-workspace", "btcr").body(Body::empty()).unwrap();
let resp = app.clone().oneshot(req).await.unwrap();
let me: Value = serde_json::from_slice(&resp.into_body().collect().await.unwrap().to_bytes()).unwrap();
assert_eq!(me["by"], json!({"agent": "codex", "workspace": "btcr"}));
call(&app, "POST", "/knowledge", Some(upsert_body("by-nobody", "plain"))).await;
let (_, h) = call(&app, "GET", "/knowledge/by-nobody/history", None).await;
assert!(h["versions"][0].get("by").is_none());
let rpc = |id: u64, name: &str, args: Value, meta: Option<Value>| {
let mut params = json!({"name": name, "arguments": args});
if let Some(m) = meta { params["_meta"] = m; }
json!({"jsonrpc": "2.0", "id": id, "method": "tools/call", "params": params})
};
let (st, v) = call(&app, "POST", "/mcp", Some(rpc(1, "kyb_task", json!({"key": "task-by-hook", "title": "T", "body": "b",
"_ctx": {"agent": "claude", "session": "sess-9", "workspace": "voiceofchain"}}), None))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert_eq!(v["result"]["isError"], Value::Null, "{v}");
let (_, h) = call(&app, "GET", "/knowledge/task-by-hook/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "claude", "session": "sess-9", "workspace": "voiceofchain", "via": "hook"}));
let (_, v) = call(&app, "POST", "/mcp", Some(rpc(2, "kyb_task", json!({"key": "task-by-ag", "title": "T", "body": "b"}),
Some(json!({"antigravity.google/conversation_id": "conv-42"}))))).await;
assert_eq!(v["result"]["isError"], Value::Null, "{v}");
let (_, h) = call(&app, "GET", "/knowledge/task-by-ag/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "antigravity", "session": "conv-42", "via": "meta"}));
call(&app, "POST", "/mcp", Some(rpc(3, "kyb_task", json!({"key": "task-by-cx", "title": "T", "body": "b"}),
Some(json!({"x-codex-turn-metadata": {"session_id": "thr-7", "turn_id": "t1"}}))))).await;
let (_, h) = call(&app, "GET", "/knowledge/task-by-cx/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "codex", "session": "thr-7", "via": "meta"}));
call(&app, "POST", "/mcp", Some(rpc(4, "kyb_task", json!({"key": "task-by-cc", "title": "T", "body": "b"}),
Some(json!({"claudecode/toolUseId": "toolu_1"}))))).await;
let (_, h) = call(&app, "GET", "/knowledge/task-by-cc/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "claude", "via": "meta"}));
call(&app, "POST", "/mcp", Some(rpc(5, "kyb_task", json!({"key": "task-by-both", "title": "T", "body": "b", "_ctx": {}}),
Some(json!({"claudecode/toolUseId": "toolu_2"}))))).await;
let (_, h) = call(&app, "GET", "/knowledge/task-by-both/history", None).await;
assert_eq!(h["versions"][0]["by"]["via"], "meta");
call(&app, "POST", "/mcp", Some(rpc(6, "kyb_task", json!({"key": "task-by-part", "title": "T", "body": "b", "_ctx": {"workspace": "btcr"}}),
Some(json!({"antigravity.google/conversation_id": "conv-9"}))))).await;
let (_, h) = call(&app, "GET", "/knowledge/task-by-part/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "antigravity", "session": "conv-9", "workspace": "btcr", "via": "meta"}));
call(&app, "POST", "/mcp", Some(rpc(7, "kyb_task", json!({"key": "task-by-cxs", "title": "T", "body": "b"}),
Some(json!({"x-codex-turn-metadata": "{\"thread_id\": \"thr-s\"}"}))))).await;
let (_, h) = call(&app, "GET", "/knowledge/task-by-cxs/history", None).await;
assert_eq!(h["versions"][0]["by"]["session"], "thr-s");
let req = Request::builder().method("POST").uri("/mcp").header("content-type", "application/json")
.header("x-kyb-agent", "cursor").header("x-kyb-workspace", "landing-rs")
.body(Body::from(rpc(8, "kyb_task", json!({"key": "task-by-hdr", "title": "T", "body": "b"}), None).to_string())).unwrap();
assert_eq!(app.clone().oneshot(req).await.unwrap().status(), StatusCode::OK);
let (_, h) = call(&app, "GET", "/knowledge/task-by-hdr/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "cursor", "workspace": "landing-rs", "via": "headers"}));
let req = Request::builder().method("POST").uri("/mcp").header("content-type", "application/json")
.header("x-kyb-agent", "cursor").header("x-kyb-workspace", "landing-rs")
.body(Body::from(rpc(9, "kyb_task", json!({"key": "task-by-hdr2", "title": "T", "body": "b"}), Some(json!({"antigravity.google/conversation_id": "conv-h"}))).to_string())).unwrap();
app.clone().oneshot(req).await.unwrap();
let (_, h) = call(&app, "GET", "/knowledge/task-by-hdr2/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "antigravity", "session": "conv-h", "workspace": "landing-rs", "via": "meta"}));
call(&app, "POST", "/mcp", Some(rpc(10, "kyb_task", json!({"key": "task-by-x1", "title": "T", "body": "b", "_ctx": {"agent": "claude"}}),
Some(json!({"x-codex-turn-metadata": {"session_id": "cx-1"}}))))).await;
let (_, h) = call(&app, "GET", "/knowledge/task-by-x1/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "claude", "via": "hook"}));
let req = Request::builder().method("POST").uri("/mcp").header("content-type", "application/json")
.header("x-kyb-agent", "cursor").header("x-kyb-session", "cursor-1").header("x-kyb-workspace", "landing-rs")
.body(Body::from(rpc(11, "kyb_task", json!({"key": "task-by-x2", "title": "T", "body": "b"}), Some(json!({"claudecode/toolUseId": "toolu_9"}))).to_string())).unwrap();
app.clone().oneshot(req).await.unwrap();
let (_, h) = call(&app, "GET", "/knowledge/task-by-x2/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "claude", "workspace": "landing-rs", "via": "meta"}), "the workspace is a place and may come from the headers; cursor's session may not");
call(&app, "POST", "/mcp", Some(rpc(12, "kyb_task", json!({"key": "task-by-x3", "title": "T", "body": "b", "_ctx": {"session": "s-only"}}),
Some(json!({"claudecode/toolUseId": "toolu_10"}))))).await;
let (_, h) = call(&app, "GET", "/knowledge/task-by-x3/history", None).await;
assert_eq!(h["versions"][0]["by"], json!({"agent": "claude", "session": "s-only", "via": "meta"}));
call(&app, "POST", "/mcp", Some(rpc(13, "kyb_task", json!({"key": "task-by-x4", "title": "T", "body": "b", "_ctx": {"session": "s-only"}}),
Some(json!({"antigravity.google/conversation_id": "conv-x"}))))).await;
let (_, h) = call(&app, "GET", "/knowledge/task-by-x4/history", None).await;
assert_eq!(h["versions"][0]["by"]["session"], "conv-x");
}
#[tokio::test]
async fn search_changed_between() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "the port is 8080"))).await;
let (st, v) =
call(&app, "GET", "/search?q=port&changed_between=2000-01-01,2999-01-01", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["count"], 1);
assert_eq!(v["semantic"], false, "a window question is not a head question");
let (_, v) =
call(&app, "GET", "/search?q=port&changed_between=2000-01-01,2000-12-31", None).await;
assert_eq!(v["count"], 0);
for body in ["revision a", "revision b", "revision c"] {
call(&app, "POST", "/knowledge", Some(upsert_body("busy", body))).await;
}
let (_, v) =
call(&app, "GET", "/search?q=revision&changed_between=2000-01-01,2999-01-01", None).await;
assert_eq!(v["count"], 1, "one row per key that moved");
assert!(v["hits"][0]["body"].as_str().unwrap().contains("revision c"));
}
#[rstest]
#[case("2026-08-01", "expected <start>,<end>")]
#[case("nonsense,2026-08-02", "must be an RFC3339")]
#[case("2026-08-05,2026-08-01", "start is after end")]
#[tokio::test]
async fn search_changed_between_rejects_garbage(#[case] value: &str, #[case] hint: &str) {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "body"))).await;
let (st, v) = call(&app, "GET", &format!("/search?changed_between={value}"), None).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{value} must be refused, got {v}");
assert!(v["error"].as_str().unwrap().contains(hint), "{v}");
}
#[tokio::test]
async fn as_of_and_changed_between_are_mutually_exclusive() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "body"))).await;
let (st, v) = call(
&app,
"GET",
"/search?as_of=2026-08-01&changed_between=2026-08-01,2026-08-02",
None,
)
.await;
assert_eq!(st, StatusCode::BAD_REQUEST);
assert!(v["error"].as_str().unwrap().contains("different questions"));
}
#[tokio::test]
async fn search_as_of_over_http() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "the port is 8080"))).await;
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "the port is 9090"))).await;
let (st, v) = call(&app, "GET", "/search?q=port&as_of=2000-01-01", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["count"], 0);
let (st, v) = call(&app, "GET", "/search?q=port&as_of=2999-01-01", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["count"], 1, "as_of returns one version per key");
assert_eq!(v["semantic"], false, "as_of must not be answered from head vectors");
assert!(v["hits"][0]["body"].as_str().unwrap().contains("9090"));
let (_, h) = call(&app, "GET", "/knowledge/svc/history", None).await;
let sha = h["versions"][0]["sha"].as_str().unwrap().to_string();
let (st, v) = call(&app, "GET", &format!("/search?q=port&as_of={sha}"), None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["count"], 1);
let (st, _) =
call(&app, "GET", "/search?q=port&as_of=2026-08-01T12%3A00%3A00Z", None).await;
assert_eq!(st, StatusCode::OK);
}
#[tokio::test]
async fn search_as_of_forgets_an_entry_deleted_over_http() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "the port is 8080"))).await;
assert_eq!(call(&app, "DELETE", "/knowledge/svc", None).await.0, StatusCode::OK);
let (_, v) = call(&app, "GET", "/search?q=port&as_of=2999-01-01", None).await;
assert_eq!(v["count"], 0, "retracted before T: no current version, got {v}");
let (_, v) = call(&app, "GET", "/search?q=port&history=true", None).await;
assert_eq!(v["count"], 1, "history still has the version that existed");
}
#[rstest]
#[case("not-a-date")]
#[case("2026-13-99")]
#[case("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef")]
#[tokio::test]
async fn search_as_of_rejects_garbage(#[case] value: &str) {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "body"))).await;
let (st, v) = call(&app, "GET", &format!("/search?as_of={value}"), None).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "as_of={value} must be refused, got {v}");
assert!(v["error"].as_str().unwrap().contains("as_of"));
}
#[tokio::test]
async fn api_edge_cases() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("alpha", "body one"))).await;
let (st, _) = call(
&app,
"GET",
"/knowledge/alpha?at=deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
None,
)
.await;
assert_eq!(st, StatusCode::NOT_FOUND);
let (st, _) = call(&app, "GET", "/knowledge/alpha?at=zzz", None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
call(&app, "DELETE", "/knowledge/alpha", None).await;
let (_, v) = call(&app, "POST", "/knowledge", Some(upsert_body("alpha", "body two"))).await;
assert_eq!(v["action"], "created");
let (_, v) = call(&app, "GET", "/knowledge/alpha/history", None).await;
let changes: Vec<&str> = v["versions"]
.as_array()
.unwrap()
.iter()
.map(|x| x["change"].as_str().unwrap())
.collect();
assert_eq!(changes, vec!["added", "deleted", "added"]);
call(&app, "POST", "/knowledge", Some(upsert_body("beta", "another entry"))).await;
let (_, v) = call(&app, "GET", "/search?q=", None).await;
assert_eq!(v["count"], 2);
let (_, v) = call(&app, "GET", "/search?q=&limit=1", None).await;
assert_eq!(v["count"], 1);
let (st, _) = call(&app, "GET", "/search?q=title%3A%28%28%28%20AND%20OR", None).await;
assert_eq!(st, StatusCode::OK);
call(
&app,
"POST",
"/knowledge",
Some(json!({"key": "gamma", "title": "t", "body": "tagged body", "tags": ["Infra"]})),
)
.await;
let (_, v) = call(&app, "GET", "/search?q=&tag=infra", None).await;
assert_eq!(v["count"], 1);
let (st, _) = call(&app, "POST", "/knowledge", Some(json!({"key": "x"}))).await;
assert!(st.is_client_error());
let (st, _) = call(&app, "DELETE", "/knowledge/void", None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
}
#[tokio::test]
async fn audit_log_written() {
let (app, _data, idx) = app_with_tmp();
call(&app, "GET", "/healthz", None).await;
call(&app, "POST", "/knowledge", Some(upsert_body("k", "plain body"))).await;
call(&app, "GET", "/search?q=plain", None).await;
let content = std::fs::read_to_string(idx.path().join("audit.jsonl")).unwrap();
let lines: Vec<&str> = content.lines().collect();
assert_eq!(lines.len(), 2, "healthz must not be audited:\n{content}");
let first: Value = serde_json::from_str(lines[0]).unwrap();
assert_eq!(first["method"], "POST");
assert_eq!(first["path"], "/knowledge");
assert_eq!(first["status"], 200);
assert!(first["ts"].as_str().unwrap().contains('T'));
let second: Value = serde_json::from_str(lines[1]).unwrap();
assert_eq!(second["path"], "/search");
assert!(second["query"].as_str().unwrap().starts_with("q="));
}
#[rstest]
#[case("GET", "/knowledge/..%2F..%2Fetc")]
#[case("GET", "/knowledge/.git")]
#[case("GET", "/knowledge/UPPER")]
#[case("GET", "/knowledge/a.b")]
#[case("DELETE", "/knowledge/..%2Fx")]
#[case("DELETE", "/knowledge/a_b")]
#[case("GET", "/knowledge/..%2Fx/history")]
#[case("GET", "/knowledge/%D0%BA%D0%BB%D1%8E%D1%87")]
#[tokio::test]
async fn traversal_and_bad_keys_rejected(#[case] method: &str, #[case] uri: &str) {
let (app, _data, _idx) = app_with_tmp();
let (st, _) = call(&app, method, uri, None).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{method} {uri}");
}
#[rstest]
#[case("GET", "/nope", 404)]
#[case("POST", "/search", 405)]
#[case("DELETE", "/search", 405)]
#[case("GET", "/reindex", 405)]
#[case("PUT", "/knowledge", 405)]
#[case("DELETE", "/knowledge", 405)]
#[case("POST", "/knowledge/some-key", 405)]
#[case("POST", "/healthz", 405)]
#[case("GET", "/knowledge/no-such-key", 404)]
#[case("GET", "/knowledge/no-such-key/history", 404)]
#[case("DELETE", "/knowledge/no-such-key", 404)]
#[tokio::test]
async fn route_status_matrix(#[case] method: &str, #[case] uri: &str, #[case] expect: u16) {
let (app, _data, _idx) = app_with_tmp();
let (st, _) = call(&app, method, uri, None).await;
assert_eq!(st.as_u16(), expect, "{method} {uri}");
}
#[rstest]
#[case(json!({"key": "k"}), 422)] #[case(json!({"key": "k", "title": "t"}), 422)] #[case(json!({"key": "", "title": "t", "body": "x"}), 400)]
#[case(json!({"key": "K", "title": "t", "body": "x"}), 400)]
#[case(json!({"key": "../up", "title": "t", "body": "x"}), 400)]
#[case(json!({"key": "k", "title": "", "body": "x"}), 400)]
#[case(json!({"key": "k", "title": " ", "body": "x"}), 400)]
#[case(json!({"key": "k", "title": "t", "body": "password: super123secret"}), 400)]
#[case(json!({"key": "k", "title": "t", "body": "x", "refs": ["ghp_abcdefghijklmnopqrstuvwxyz1234"]}), 400)]
#[case(json!({"key": "k", "title": "t", "body": "clean body"}), 200)]
#[case(json!({"key": "k2", "title": "t", "body": ""}), 200)] #[case(json!({"key": "k3", "title": "t", "body": "x", "tags": [], "refs": []}), 200)]
#[tokio::test]
async fn upsert_validation_matrix(#[case] payload: Value, #[case] expect: u16) {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "POST", "/knowledge", Some(payload)).await;
assert_eq!(st.as_u16(), expect, "response: {v}");
}
#[tokio::test]
async fn api_concurrent_same_key() {
let (app, _data, _idx) = app_with_tmp();
let mut set = tokio::task::JoinSet::new();
for i in 0..12 {
let app = app.clone();
set.spawn(async move {
let body = json!({
"key": "same-key",
"title": "Shared key",
"body": format!("unique body {i}"),
});
call(&app, "POST", "/knowledge", Some(body)).await
});
}
while let Some(res) = set.join_next().await {
let (st, v) = res.unwrap();
assert_eq!(st, StatusCode::OK, "{v}");
assert_eq!(v["changed"], true);
}
let (_, v) = call(&app, "GET", "/knowledge/same-key/history", None).await;
assert_eq!(v["versions"].as_array().unwrap().len(), 12);
let (_, v) = call(&app, "POST", "/reindex", None).await;
assert_eq!(v["head_docs"], 1);
assert_eq!(v["history_docs"], 12);
let (_, v) = call(&app, "GET", "/knowledge/same-key", None).await;
assert!(v["body"].as_str().unwrap().starts_with("unique body"));
}
fn incident_body(key: &str, status: &str, body: &str) -> Value {
json!({
"key": key, "title": "orders_api OOM on host-a", "body": body,
"service": "orders_api", "hosts": ["host-a"], "severity": "high", "status": status,
"knowledge": ["orders-api-architecture"], "tags": ["acme"],
})
}
#[tokio::test]
async fn incident_full_flow() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(json!({
"key": "orders-api-architecture", "title": "orders_api: gRPC gateway",
"body": "The single write path into ClickHouse.", "tags": ["acme"],
}))).await;
let key = "inc-2026-07-22-orders-api-oom";
let (st, v) = call(&app, "POST", "/incidents",
Some(incident_body(key, "open", "What happened: OOM. Workaround: restart."))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert_eq!(v["action"], "created");
assert!(v.get("unknown_knowledge").is_none(), "{v}");
let (_, v) = call(&app, "POST", "/incidents", Some(json!({
"key": "inc-2026-07-21-landing-gap", "title": "landing gap", "body": "Data gap.",
"service": "web_app", "severity": "medium",
"knowledge": ["landing-architecture"],
}))).await;
assert_eq!(v["unknown_knowledge"], json!(["landing-architecture"]));
let (_, v) = call(&app, "GET", "/knowledge/inc-2026-07-21-landing-gap", None).await;
assert_eq!(v["status"], "open");
assert_eq!(v["kind"], "incident");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["service"], "orders_api");
assert_eq!(v["severity"], "high");
assert_eq!(v["hosts"], json!(["host-a"]));
assert_eq!(v["knowledge"], json!(["orders-api-architecture"]));
let (_, v) = call(&app, "GET", "/knowledge/orders-api-architecture", None).await;
assert_eq!(v["kind"], "knowledge");
assert!(v.get("status").is_none(), "{v}");
let (_, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(v["open_incidents"], 2);
let (_, v) = call(&app, "GET", "/incidents", None).await;
assert_eq!(v["count"], 2);
let (_, v) = call(&app, "GET", "/incidents?status=&service=&limit=50", None).await;
assert_eq!(v["count"], 2, "{v}");
let (_, v) = call(&app, "GET", "/incidents?service=ORDERS_API", None).await;
assert_eq!(v["count"], 1, "service filter is case-insensitive: {v}");
assert_eq!(v["incidents"][0]["key"], key);
let (_, v) = call(&app, "GET", "/search?q=&kind=incident", None).await;
assert_eq!(v["count"], 2);
let (_, v) = call(&app, "GET", "/search?q=&kind=knowledge", None).await;
assert_eq!(v["count"], 1);
let (_, v) = call(&app, "GET", "/search?q=&kind=&status=&service=", None).await;
assert_eq!(v["count"], 3);
let (_, v) = call(&app, "GET", "/search?q=orders%20api&kind=incident&status=open&service=orders_api", None).await;
assert_eq!(v["count"], 1, "{v}");
assert_eq!(v["hits"][0]["key"], key);
assert_eq!(v["hits"][0]["status"], "open");
let (st, v) = call(&app, "POST", &format!("/incidents/{key}/resolve"), Some(json!({}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{v}");
assert!(v["error"].as_str().unwrap().contains("resolution"));
let (st, v) = call(&app, "POST", &format!("/incidents/{key}/resolve"),
Some(json!({"resolution": "Raised the memory limit to 2G; fixed the batch flush leak."}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert_eq!(v["action"], "updated");
assert_eq!(v["archived"], true, "{v}");
let (_, v) = call(&app, "GET", "/incidents?status=open", None).await;
assert_eq!(v["count"], 1);
let (_, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(v["open_incidents"], 1);
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["status"], "resolved");
assert_eq!(v["archived"], true, "{v}");
assert!(v["resolution"].as_str().unwrap().contains("memory limit"));
assert_eq!(v["service"], "orders_api");
assert_eq!(v["knowledge"], json!(["orders-api-architecture"]));
assert!(v["body"].as_str().unwrap().contains("What happened"));
let (_, v) = call(&app, "GET", "/incidents", None).await;
assert_eq!(v["count"], 1, "archived hidden by default: {v}");
let (_, v) = call(&app, "GET", "/incidents?all=true", None).await;
assert_eq!(v["count"], 2);
assert_eq!(v["incidents"][1]["key"], key);
assert_eq!(v["incidents"][1]["status"], "resolved");
assert_eq!(v["incidents"][1]["archived"], true);
let (_, v) = call(&app, "GET", "/incidents?status=resolved", None).await;
assert_eq!(v["count"], 1, "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}/history"), None).await;
assert_eq!(v["versions"].as_array().unwrap().len(), 3);
assert_eq!(v["versions"][0]["change"], "deleted");
assert!(v["versions"][0]["message"].as_str().unwrap().contains("archive"));
let (_, v) = call(&app, "GET", "/search?q=memory%20limit&kind=incident", None).await;
assert_eq!(v["count"], 1, "{v}");
assert!(v["hits"][0]["resolution"].as_str().unwrap().contains("2G"));
assert_eq!(v["hits"][0]["is_head"], true);
let (_, v) = call(&app, "POST", &format!("/incidents/{key}/resolve"),
Some(json!({"status": "mitigated"}))).await;
assert_eq!(v["action"], "created", "reopen recreates the file: {v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["status"], "mitigated");
assert!(v.get("archived").is_none(), "back in the tree: {v}");
assert!(v["resolution"].as_str().unwrap().contains("memory limit"), "kept: {v}");
}
#[tokio::test]
async fn incident_actionable_fields_flow() {
let (app, _data, _idx) = app_with_tmp();
let key = "inc-2026-07-22-symbol-mismap";
let (st, v) = call(&app, "POST", "/incidents", Some(json!({
"key": key, "title": "prices 50x off after symbol remap", "service": "web_app2",
"hosts": ["host-b"], "severity": "high",
"detection": "per (exchange,symbol): price > 50x yesterday max; healthy = 0 rows",
"affected": [
{"scope": "okx", "from": "2026-07-22T08:09:40Z", "to": "2026-07-22T21:09:37Z"},
{"scope": "gateio", "from": "2026-07-22T08:20:09Z", "to": "2026-07-22T20:04:41Z"},
],
"started_at": "2026-07-22T08:09:40Z",
"body": "Symptom: heatmap shows +38,000,000% gainers.\n\nFollow-ups:\n- [ ] guard dev NATS\n- [x] webui sanity filter\n",
}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["affected"].as_array().unwrap().len(), 2);
assert_eq!(v["affected"][0]["scope"], "okx");
assert_eq!(v["started_at"], "2026-07-22T08:09:40Z");
assert!(v["detected_at"].as_str().unwrap().contains('T'), "stamped: {v}");
assert_eq!(v["resolved_at"], "");
assert_eq!(v["open_followups"], 1);
let (_, v) = call(&app, "GET", "/incidents", None).await;
assert!(v["incidents"][0]["detection"].as_str().unwrap().contains("50x"));
assert_eq!(v["incidents"][0]["open_followups"], 1);
let (_, v) = call(&app, "GET", "/incidents?followups=open", None).await;
assert_eq!(v["count"], 1);
let (_, v) = call(&app, "GET", "/search?q=mismap&kind=incident", None).await;
assert_eq!(v["hits"][0]["affected"].as_array().unwrap().len(), 2, "{v}");
assert!(v["hits"][0]["detection"].as_str().unwrap().contains("healthy"));
let (_, v) = call(&app, "GET", "/search?q=yesterday%20max", None).await;
assert_eq!(v["count"], 1);
let (_, v) = call(&app, "POST", &format!("/incidents/{key}/resolve"),
Some(json!({"resolution": "Recorders restarted; windows purged from CH."}))).await;
assert_eq!(v["open_followups"], 1, "{v}");
assert!(v["warning"].as_str().unwrap().contains("follow-up"));
assert_eq!(v["archived"], true);
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert!(v["resolved_at"].as_str().unwrap().contains('T'));
let (_, v) = call(&app, "GET", "/incidents?followups=open", None).await;
assert_eq!(v["count"], 1, "resolved but loose ends still listed");
let (_, v) = call(&app, "POST", "/incidents", Some(json!({
"key": key, "title": "prices 50x off after symbol remap", "service": "web_app2",
"hosts": ["host-b"], "severity": "high", "status": "resolved",
"resolution": "Recorders restarted; windows purged from CH.",
"body": "Everything from before, follow-ups all done:\n- [x] guard dev NATS\n",
}))).await;
assert_eq!(v["action"], "created", "re-filing an archived report recreates the file: {v}");
assert_eq!(v["archived"], true, "and a closed status archives it again: {v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["started_at"], "2026-07-22T08:09:40Z", "inherited: {v}");
assert!(v["resolved_at"].as_str().unwrap().contains('T'), "inherited: {v}");
assert_eq!(v["open_followups"], 0);
let (_, v) = call(&app, "GET", "/incidents?followups=open", None).await;
assert_eq!(v["count"], 0);
}
#[tokio::test]
async fn mitigated_timestamp_stamped() {
let (app, _data, _idx) = app_with_tmp();
let key = "inc-2026-07-23-nats-lag";
call(&app, "POST", "/incidents", Some(json!({
"key": key, "title": "lag", "body": "x", "service": "nats", "severity": "low",
}))).await;
call(&app, "POST", &format!("/incidents/{key}/resolve"),
Some(json!({"status": "mitigated", "resolution": "hourly restart cron while the fix bakes"}))).await;
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["status"], "mitigated");
assert!(v["mitigated_at"].as_str().unwrap().contains('T'), "{v}");
assert_eq!(v["resolved_at"], "");
}
#[rstest]
#[case::window_missing_to(json!({"key": "inc-w", "title": "t", "body": "x", "service": "s", "severity": "low",
"affected": [{"scope": "okx", "from": "2026-07-22T08:00:00Z", "to": ""}]}), 400)]
#[case::window_ok(json!({"key": "inc-w", "title": "t", "body": "x", "service": "s", "severity": "low",
"affected": [{"scope": "okx", "from": "2026-07-22T08:00:00Z", "to": "2026-07-22T09:00:00Z"}]}), 200)]
#[tokio::test]
async fn affected_window_validation(#[case] payload: Value, #[case] expect: u16) {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "POST", "/incidents", Some(payload)).await;
assert_eq!(st.as_u16(), expect, "response: {v}");
}
#[tokio::test]
async fn structure_hints() {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "POST", "/incidents", Some(json!({
"key": "inc-2026-07-23-bare", "title": "t", "body": "something broke",
"service": "s", "severity": "low",
}))).await;
assert_eq!(st, StatusCode::OK);
let hints = v["hints"].as_array().unwrap();
assert_eq!(hints.len(), 4, "{v}");
assert!(hints.iter().any(|h| h.as_str().unwrap().contains("detection")));
let (_, v) = call(&app, "POST", "/incidents", Some(json!({
"key": "inc-2026-07-23-full", "title": "t",
"body": "Symptom: x.\nRoot cause (verified): y.\nFollow-ups:\n- [ ] z\n",
"service": "s", "severity": "low",
"detection": "check: 0 rows when healthy",
"affected": [{"scope": "a", "from": "b", "to": "c"}],
}))).await;
assert!(v.get("hints").is_none(), "{v}");
}
#[tokio::test]
async fn resolve_edge_cases() {
let (app, _data, _idx) = app_with_tmp();
let (st, _) = call(&app, "POST", "/incidents/inc-nope/resolve",
Some(json!({"resolution": "x"}))).await;
assert_eq!(st, StatusCode::NOT_FOUND);
call(&app, "POST", "/knowledge", Some(upsert_body("plain", "a fact"))).await;
let (st, v) = call(&app, "POST", "/knowledge/../resolve", Some(json!({"resolution": "x"}))).await;
assert!(st.is_client_error(), "{v}");
let (st, v) = call(&app, "POST", "/incidents/plain/resolve",
Some(json!({"resolution": "x"}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{v}");
assert!(v["error"].as_str().unwrap().contains("not an incident"));
}
#[rstest]
#[case::key_without_prefix(json!({"key": "orders-api-oom", "title": "t", "body": "x", "service": "s", "severity": "high"}), 400)]
#[case::missing_service(json!({"key": "inc-a", "title": "t", "body": "x", "severity": "high"}), 422)]
#[case::empty_service(json!({"key": "inc-a", "title": "t", "body": "x", "service": " ", "severity": "high"}), 400)]
#[case::bad_severity(json!({"key": "inc-a", "title": "t", "body": "x", "service": "s", "severity": "huge"}), 400)]
#[case::bad_status(json!({"key": "inc-a", "title": "t", "body": "x", "service": "s", "severity": "low", "status": "wip"}), 400)]
#[case::bad_knowledge(json!({"key": "inc-a", "title": "t", "body": "x", "service": "s", "severity": "low", "knowledge": ["Bad Key"]}), 400)]
#[case::secret_in_body(json!({"key": "inc-a", "title": "t", "body": "password: super123secret", "service": "s", "severity": "low"}), 400)]
#[case::resolved_needs_resolution(json!({"key": "inc-a", "title": "t", "body": "x", "service": "s", "severity": "low", "status": "resolved"}), 400)]
#[case::resolved_with_resolution(json!({"key": "inc-a", "title": "t", "body": "x", "service": "s", "severity": "low", "status": "resolved", "resolution": "fixed by restart"}), 200)]
#[case::minimal_ok(json!({"key": "inc-a", "title": "t", "body": "x", "service": "s", "severity": "low"}), 200)]
#[tokio::test]
async fn incident_validation_matrix(#[case] payload: Value, #[case] expect: u16) {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "POST", "/incidents", Some(payload)).await;
assert_eq!(st.as_u16(), expect, "response: {v}");
}
#[tokio::test]
async fn knowledge_cannot_take_inc_keys() {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "POST", "/knowledge",
Some(json!({"key": "inc-2026-07-22-fake", "title": "t", "body": "x"}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{v}");
assert!(v["error"].as_str().unwrap().contains("reserved"));
}
#[tokio::test]
async fn incident_delete_and_history_search() {
let (app, _data, _idx) = app_with_tmp();
let key = "inc-2026-07-20-nats-lag";
let (_, v) = call(&app, "POST", "/incidents", Some(json!({
"key": key, "title": "NATS consumer lag", "body": "Consumers fell behind.",
"service": "nats", "severity": "low", "status": "resolved",
"resolution": "Consumers caught up after the stream limit was raised.",
}))).await;
assert_eq!(v["archived"], true, "{v}");
let (st, _) = call(&app, "DELETE", &format!("/knowledge/{key}"), None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
let (_, v) = call(&app, "GET", "/incidents", None).await;
assert_eq!(v["count"], 0, "archived hidden from the default listing: {v}");
let (_, v) = call(&app, "GET", "/incidents?all=true", None).await;
assert_eq!(v["count"], 1);
assert_eq!(v["incidents"][0]["archived"], true);
let (_, v) = call(&app, "GET", "/search?q=consumer&kind=incident", None).await;
assert_eq!(v["count"], 1, "{v}");
assert_eq!(v["hits"][0]["is_head"], true);
assert!(v["hits"][0]["resolution"].as_str().unwrap().contains("stream limit"));
let (_, v) = call(&app, "GET", "/search?q=consumer&history=true&kind=incident", None).await;
assert_eq!(v["count"], 1, "{v}");
assert_eq!(v["hits"][0]["is_head"], false);
let key2 = "inc-2026-07-21-open-one";
call(&app, "POST", "/incidents", Some(json!({
"key": key2, "title": "open one", "body": "x", "service": "nats", "severity": "low",
}))).await;
let (_, v) = call(&app, "DELETE", &format!("/knowledge/{key2}"), None).await;
assert_eq!(v["archived"], true, "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key2}"), None).await;
assert_eq!(v["archived"], true, "readable after archive: {v}");
}
#[tokio::test]
async fn task_full_flow() {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "POST", "/knowledge",
Some(json!({"key": "task-fake", "title": "t", "body": "x"}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{v}");
assert!(v["error"].as_str().unwrap().contains("reserved"));
let (st, v) = call(&app, "POST", "/tasks",
Some(json!({"key": "fix-logs", "title": "t", "body": "x"}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{v}");
let key = "task-raise-log-retention";
let (st, v) = call(&app, "POST", "/tasks", Some(json!({
"key": key, "title": "Raise container log retention to 72h",
"body": "Short retention loses evidence.\n\n- [ ] measure log volume first\n",
"tags": ["idea", "observability"],
"knowledge": ["web-app-architecture"],
}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert_eq!(v["action"], "created");
assert_eq!(v["unknown_knowledge"], json!(["web-app-architecture"]));
let (_, v) = call(&app, "GET", "/tasks", None).await;
assert_eq!(v["count"], 1);
assert_eq!(v["tasks"][0]["status"], "open");
assert_eq!(v["tasks"][0]["archived"], false);
assert_eq!(v["tasks"][0]["open_followups"], 1);
let (_, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(v["open_tasks"], 1);
let (_, v) = call(&app, "GET", "/search?q=&kind=task", None).await;
assert_eq!(v["count"], 1);
let (st, v) = call(&app, "POST", &format!("/tasks/{key}/resolve"), Some(json!({}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{v}");
assert!(v["error"].as_str().unwrap().contains("resolution"));
let (st, v) = call(&app, "POST", &format!("/tasks/{key}/resolve"),
Some(json!({"resolution": "Retention raised to 72h with a 2G disk budget."}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert_eq!(v["archived"], true, "{v}");
let (_, v) = call(&app, "GET", "/tasks", None).await;
assert_eq!(v["count"], 0, "archived hidden by default: {v}");
let (_, v) = call(&app, "GET", "/tasks?all=true", None).await;
assert_eq!(v["count"], 1);
assert_eq!(v["tasks"][0]["status"], "done");
assert_eq!(v["tasks"][0]["archived"], true);
let (_, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(v["open_tasks"], 0);
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["kind"], "task");
assert_eq!(v["archived"], true);
assert!(v["resolved_at"].as_str().unwrap().contains('T'), "stamped: {v}");
let (_, v) = call(&app, "GET", "/search?q=retention%20disk&kind=task", None).await;
assert_eq!(v["count"], 1, "{v}");
assert_eq!(v["hits"][0]["is_head"], true);
call(&app, "POST", "/tasks", Some(json!({
"key": "task-try-foo", "title": "Try foo", "body": "x",
}))).await;
let (_, v) = call(&app, "POST", "/tasks/task-try-foo/resolve",
Some(json!({"status": "dropped", "resolution": "Obsolete after the bar rewrite."}))).await;
assert_eq!(v["archived"], true, "{v}");
let (_, v) = call(&app, "GET", "/tasks?all=true", None).await;
assert_eq!(v["count"], 2);
assert_eq!(v["tasks"][0]["status"], "done");
assert_eq!(v["tasks"][1]["status"], "dropped");
let (st, v) = call(&app, "POST", &format!("/incidents/{key}/resolve"),
Some(json!({"resolution": "x"}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{v}");
assert!(v["error"].as_str().unwrap().contains("not an incident"));
}
#[tokio::test]
async fn task_priority_and_status_flow() {
let (app, _data, _idx) = app_with_tmp();
let key = "task-raise-log-retention";
let (st, v) = call(&app, "POST", "/tasks", Some(json!({
"key": key, "title": "Raise container log retention to 72h",
"body": "Short retention loses evidence.", "priority": "high",
}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["priority"], "high");
assert_eq!(v["blocked_reason"], "");
assert_eq!(v["status"], "open");
call(&app, "POST", "/tasks", Some(json!({
"key": "task-try-foo", "title": "Try foo", "body": "an idea",
}))).await;
let (_, v) = call(&app, "GET", "/knowledge/task-try-foo", None).await;
assert_eq!(v["priority"], "", "{v}");
call(&app, "POST", "/tasks", Some(json!({
"key": "task-swap-disk", "title": "Swap the failing disk", "body": "x",
"priority": "critical", "status": "in_progress",
}))).await;
let (_, v) = call(&app, "GET", "/tasks?priority=high", None).await;
assert_eq!(v["count"], 1, "{v}");
assert_eq!(v["tasks"][0]["key"], key);
assert_eq!(v["tasks"][0]["priority"], "high");
let (_, v) = call(&app, "GET", "/tasks?priority=low", None).await;
assert_eq!(v["count"], 0);
let (_, v) = call(&app, "GET", "/tasks?status=&priority=&limit=50", None).await;
assert_eq!(v["count"], 3, "{v}");
let (_, v) = call(&app, "GET", "/tasks?status=in_progress&priority=critical", None).await;
assert_eq!(v["count"], 1, "{v}");
assert_eq!(v["tasks"][0]["key"], "task-swap-disk");
let (_, v) = call(&app, "GET", "/search?q=&kind=task&priority=critical", None).await;
assert_eq!(v["count"], 1, "{v}");
assert_eq!(v["hits"][0]["key"], "task-swap-disk");
assert_eq!(v["hits"][0]["priority"], "critical");
let (st, v) = call(&app, "POST", "/tasks", Some(json!({
"key": "task-swap-disk", "title": "Swap the failing disk", "body": "x",
"priority": "critical", "status": "blocked",
"blocked_reason": "waiting on the replacement disk to arrive",
}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert!(v.get("archived").is_none(), "blocked is not an ending: {v}");
let (_, v) = call(&app, "GET", "/knowledge/task-swap-disk", None).await;
assert_eq!(v["status"], "blocked");
assert_eq!(v["blocked_reason"], "waiting on the replacement disk to arrive");
assert!(v.get("archived").is_none(), "still live in the canon: {v}");
let (_, v) = call(&app, "GET", "/tasks?status=blocked", None).await;
assert_eq!(v["tasks"][0]["blocked_reason"], "waiting on the replacement disk to arrive");
let (_, v) = call(&app, "GET", "/search?q=&kind=task&status=blocked", None).await;
assert_eq!(v["hits"][0]["blocked_reason"], "waiting on the replacement disk to arrive");
let (_, v) = call(&app, "GET", "/tasks", None).await;
assert_eq!(v["count"], 3, "open + in_progress(now blocked) + open: {v}");
let (_, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(v["open_tasks"], 3, "blocked and in_progress count as work: {v}");
let (_, v) = call(&app, "POST", "/tasks/task-swap-disk/resolve",
Some(json!({"status": "in_progress"}))).await;
assert_eq!(v["changed"], true, "{v}");
let (_, v) = call(&app, "GET", "/knowledge/task-swap-disk", None).await;
assert_eq!(v["status"], "in_progress");
assert_eq!(v["blocked_reason"], "", "stale reason dropped: {v}");
assert_eq!(v["priority"], "critical", "priority survives the transition: {v}");
let (_, v) = call(&app, "POST", "/tasks/task-swap-disk/resolve",
Some(json!({"resolution": "New disk installed and the array rebuilt."}))).await;
assert_eq!(v["archived"], true, "{v}");
let (_, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(v["open_tasks"], 2);
let (_, v) = call(&app, "GET", "/tasks", None).await;
assert_eq!(v["count"], 2, "archived hidden by default: {v}");
let (_, v) = call(&app, "GET", "/knowledge/task-swap-disk", None).await;
assert_eq!(v["archived"], true);
assert_eq!(v["priority"], "critical", "{v}");
assert_eq!(v["status"], "done");
let (_, v) = call(&app, "GET", "/tasks?all=true&priority=critical", None).await;
assert_eq!(v["count"], 1, "the archive answers the priority filter too: {v}");
assert_eq!(v["tasks"][0]["archived"], true);
call(&app, "POST", "/tasks", Some(json!({
"key": "task-try-foo", "title": "Try foo", "body": "an idea",
"status": "blocked", "blocked_reason": "waiting on the bar rewrite",
}))).await;
let (_, v) = call(&app, "POST", "/tasks/task-try-foo/resolve",
Some(json!({"status": "dropped", "resolution": "Obsolete after the bar rewrite."}))).await;
assert_eq!(v["archived"], true, "{v}");
let (_, v) = call(&app, "GET", "/knowledge/task-try-foo", None).await;
assert_eq!(v["status"], "dropped");
assert_eq!(v["blocked_reason"], "", "{v}");
}
#[tokio::test]
async fn task_ownership_and_parent_flow() {
let (app, _data, _idx) = app_with_tmp();
let parent = "task-migrate-logs";
let (st, v) = call(&app, "POST", "/tasks", Some(json!({
"key": parent, "title": "Migrate the log pipeline", "body": "The umbrella task.",
"status": "in_progress", "priority": "high", "assignee": "agent-a",
}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert!(v.get("unknown_parent").is_none(), "a top-level task has no parent: {v}");
let child = "task-migrate-logs-step-one";
let (st, v) = call(&app, "POST", "/tasks", Some(json!({
"key": child, "title": "Step one: measure the volume", "body": "x",
"assignee": "agent-b", "parent_task": parent,
}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert!(v.get("unknown_parent").is_none(), "the parent exists: {v}");
let (st, v) = call(&app, "POST", "/tasks", Some(json!({
"key": "task-orphan", "title": "Filed before its parent", "body": "x",
"parent_task": "task-not-written-yet",
}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert_eq!(v["unknown_parent"], "task-not-written-yet");
let (_, v) = call(&app, "GET", &format!("/knowledge/{child}"), None).await;
assert_eq!(v["assignee"], "agent-b");
assert_eq!(v["parent_task"], parent);
let (_, v) = call(&app, "GET", "/knowledge/task-orphan", None).await;
assert_eq!(v["assignee"], "", "{v}");
assert_eq!(v["parent_task"], "task-not-written-yet");
let (_, v) = call(&app, "GET", "/tasks?assignee=agent-a", None).await;
assert_eq!(v["count"], 1, "{v}");
assert_eq!(v["tasks"][0]["key"], parent);
assert_eq!(v["tasks"][0]["assignee"], "agent-a");
let (_, v) = call(&app, "GET", &format!("/tasks?parent_task={parent}"), None).await;
assert_eq!(v["count"], 1, "{v}");
assert_eq!(v["tasks"][0]["key"], child);
assert_eq!(v["tasks"][0]["parent_task"], parent);
let (_, v) = call(&app, "GET", "/tasks?assignee=agent-nobody", None).await;
assert_eq!(v["count"], 0);
let (_, v) = call(&app, "GET", "/tasks?assignee=&parent_task=&limit=50", None).await;
assert_eq!(v["count"], 3, "{v}");
let (_, v) = call(&app, "GET", "/search?q=&kind=task&assignee=agent-b", None).await;
assert_eq!(v["count"], 1, "{v}");
assert_eq!(v["hits"][0]["key"], child);
assert_eq!(v["hits"][0]["assignee"], "agent-b");
assert_eq!(v["hits"][0]["parent_task"], parent);
let (_, v) =
call(&app, "GET", &format!("/search?q=&kind=task&parent_task={parent}"), None).await;
assert_eq!(v["count"], 1, "{v}");
let (_, v) = call(&app, "GET", "/search?q=&kind=task&assignee=&parent_task=", None).await;
assert_eq!(v["count"], 3, "{v}");
call(&app, "POST", &format!("/tasks/{parent}/resolve"),
Some(json!({"resolution": "Pipeline migrated."}))).await;
let (_, v) = call(&app, "POST", "/tasks", Some(json!({
"key": "task-migrate-logs-step-two", "title": "Step two", "body": "x",
"parent_task": parent,
}))).await;
assert!(v.get("unknown_parent").is_none(), "an archived parent still exists: {v}");
}
#[tokio::test]
async fn task_transition_partial_updates() {
let (app, _data, _idx) = app_with_tmp();
let key = "task-raise-log-retention";
call(&app, "POST", "/tasks", Some(json!({
"key": key, "title": "Raise container log retention to 72h",
"body": "Short retention loses evidence.\n\n- [ ] measure log volume first\n",
"priority": "high", "tags": ["observability"],
"knowledge": ["web-app-architecture"], "refs": ["see the compose file on the log host"],
}))).await;
let (st, v) = call(&app, "POST", &format!("/tasks/{key}/transition"),
Some(json!({"status": "in_progress", "assignee": "agent-a"}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
assert_eq!(v["changed"], true);
assert_eq!(v["action"], "updated");
assert_eq!(v["status"], "in_progress");
assert_eq!(v["assignee"], "agent-a");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["status"], "in_progress");
assert_eq!(v["assignee"], "agent-a");
assert_eq!(v["title"], "Raise container log retention to 72h", "title kept: {v}");
assert_eq!(v["priority"], "high", "omitted metadata survives: {v}");
assert_eq!(v["tags"], json!(["observability"]));
assert_eq!(v["refs"], json!(["see the compose file on the log host"]));
assert_eq!(v["knowledge"], json!(["web-app-architecture"]));
assert!(v["body"].as_str().unwrap().contains("measure log volume"), "body kept: {v}");
assert_eq!(v["open_followups"], 1);
assert!(v.get("archived").is_none(), "a live transition never archives: {v}");
let (_, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(v["open_tasks"], 1, "still work in flight: {v}");
let (_, v) = call(&app, "POST", &format!("/tasks/{key}/transition"),
Some(json!({"status": "blocked", "blocked_reason": "waiting on the disk budget approval"}))).await;
assert_eq!(v["status"], "blocked", "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["blocked_reason"], "waiting on the disk budget approval");
assert_eq!(v["assignee"], "agent-a", "an omitted assignee is kept: {v}");
assert_eq!(v["priority"], "high");
let (_, v) = call(&app, "POST", &format!("/tasks/{key}/transition"),
Some(json!({"status": "in_progress"}))).await;
assert_eq!(v["changed"], true, "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["blocked_reason"], "", "stale reason dropped: {v}");
assert_eq!(v["status"], "in_progress");
let (_, v) = call(&app, "POST", &format!("/tasks/{key}/transition"),
Some(json!({"status": "open", "assignee": ""}))).await;
assert_eq!(v["assignee"], "", "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["assignee"], "");
assert_eq!(v["status"], "open");
let (_, v) = call(&app, "POST", &format!("/tasks/{key}/transition"),
Some(json!({"status": "in_progress", "parent_task": "task-migrate-logs"}))).await;
assert_eq!(v["unknown_parent"], "task-migrate-logs", "forward reference reported: {v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["parent_task"], "task-migrate-logs");
assert_eq!(v["priority"], "high", "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}/history"), None).await;
let versions = v["versions"].as_array().unwrap().clone();
assert_eq!(versions.len(), 6, "create + 5 transitions: {versions:?}");
let claimed = versions[versions.len() - 2]["sha"].as_str().unwrap().to_string();
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}?at={claimed}"), None).await;
assert_eq!(v["assignee"], "agent-a", "the earlier owner is reconstructable: {v}");
assert_eq!(v["status"], "in_progress");
let (_, v) = call(&app, "POST", &format!("/tasks/{key}/resolve"),
Some(json!({"resolution": "Raised to 72h with a 2G disk budget."}))).await;
assert_eq!(v["archived"], true, "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["status"], "done");
assert_eq!(v["parent_task"], "task-migrate-logs", "{v}");
let (_, v) = call(&app, "POST", &format!("/tasks/{key}/transition"),
Some(json!({"status": "in_progress", "assignee": "agent-b"}))).await;
assert_eq!(v["action"], "created", "reopening recreates the file: {v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert!(v.get("archived").is_none(), "back in the canon: {v}");
assert_eq!(v["assignee"], "agent-b");
}
#[tokio::test]
async fn task_parent_cycles_rejected() {
let (app, _data, _idx) = app_with_tmp();
for (key, parent) in [
("task-project", ""),
("task-project-step-one", "task-project"),
("task-project-step-two", "task-project-step-one"),
] {
let (st, v) = call(&app, "POST", "/tasks", Some(json!({
"key": key, "title": key, "body": "x", "parent_task": parent,
}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
}
let (st, v) = call(&app, "POST", "/tasks", Some(json!({
"key": "task-project", "title": "task-project", "body": "x",
"parent_task": "task-project-step-two",
}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{v}");
assert!(v["error"].as_str().unwrap().contains("cycle"), "{v}");
let (st, v) = call(&app, "POST", "/tasks/task-project/transition", Some(json!({
"status": "in_progress", "parent_task": "task-project-step-two",
}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{v}");
assert!(v["error"].as_str().unwrap().contains("cycle"), "{v}");
let (_, v) = call(&app, "GET", "/knowledge/task-project", None).await;
assert_eq!(v["status"], "open", "{v}");
assert_eq!(v["parent_task"], "", "{v}");
}
#[tokio::test]
async fn task_transition_rejections() {
let (app, _data, _idx) = app_with_tmp();
let key = "task-swap-disk";
call(&app, "POST", "/tasks", Some(json!({
"key": key, "title": "Swap the failing disk", "body": "x", "priority": "critical",
}))).await;
call(&app, "POST", "/knowledge", Some(upsert_body("plain-note", "a fact"))).await;
for status in ["done", "dropped"] {
let (st, v) = call(&app, "POST", &format!("/tasks/{key}/transition"),
Some(json!({"status": status}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{status}: {v}");
let err = v["error"].as_str().unwrap();
assert!(err.contains("kyb done"), "{status}: {err}");
assert!(err.contains("/resolve"), "{status}: {err}");
}
let bad = [
json!({"status": "wip"}),
json!({"status": ""}),
json!({"status": "mitigated"}),
json!({"status": "in_progress", "assignee": "token: ghp_abcdefghijklmnopqrstuvwxyz123456"}),
json!({"status": "in_progress", "assignee": "x".repeat(model::ASSIGNEE_MAX_LEN + 1)}),
json!({"status": "in_progress", "parent_task": "not-a-task-key"}),
json!({"status": "in_progress", "parent_task": "inc-2026-08-15-oom"}),
];
for payload in bad {
let (st, v) =
call(&app, "POST", &format!("/tasks/{key}/transition"), Some(payload.clone())).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "payload {payload}: {v}");
}
let (st, v) = call(&app, "POST", &format!("/tasks/{key}/transition"),
Some(json!({"status": "in_progress", "parent_task": key}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "self-parenting: {v}");
assert!(v["error"].as_str().unwrap().contains("own parent"), "{v}");
let (st, v) = call(&app, "POST", "/tasks/plain-note/transition",
Some(json!({"status": "in_progress"}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST, "{v}");
assert!(v["error"].as_str().unwrap().contains("not a task"), "{v}");
let (st, _) = call(&app, "POST", "/tasks/task-nope/transition",
Some(json!({"status": "in_progress"}))).await;
assert_eq!(st, StatusCode::NOT_FOUND);
let (st, _) = call(&app, "POST", "/tasks/Bad%20Key/transition",
Some(json!({"status": "in_progress"}))).await;
assert_eq!(st, StatusCode::BAD_REQUEST);
let (st, _) = call(&app, "POST", &format!("/tasks/{key}/transition"), Some(json!({}))).await;
assert!(st.is_client_error(), "status is required");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["status"], "open", "{v}");
assert_eq!(v["assignee"], "");
assert_eq!(v["parent_task"], "");
assert_eq!(v["priority"], "critical");
}
#[tokio::test]
async fn legacy_task_without_ownership_still_works() {
let (app, _data, _idx) = app_with_tmp();
let key = "task-old-note";
let (st, v) = call(&app, "POST", "/tasks", Some(json!({
"key": key, "title": "An old note", "body": "written before ownership existed",
}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["assignee"], "", "{v}");
assert_eq!(v["parent_task"], "");
assert_eq!(v["status"], "open");
let (_, v) = call(&app, "GET", "/tasks", None).await;
assert_eq!(v["count"], 1);
assert_eq!(v["tasks"][0]["assignee"], "");
assert_eq!(v["tasks"][0]["parent_task"], "");
let (st, v) = call(&app, "POST", &format!("/tasks/{key}/transition"),
Some(json!({"status": "in_progress", "assignee": "agent-a"}))).await;
assert_eq!(st, StatusCode::OK, "{v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["assignee"], "agent-a");
assert!(v["body"].as_str().unwrap().contains("before ownership"), "{v}");
}
#[rstest]
#[case::priority_high(json!({"key": "task-a", "title": "t", "body": "x", "priority": "high"}), 200)]
#[case::priority_absent(json!({"key": "task-a", "title": "t", "body": "x"}), 200)]
#[case::priority_empty(json!({"key": "task-a", "title": "t", "body": "x", "priority": ""}), 200)]
#[case::priority_unknown(json!({"key": "task-a", "title": "t", "body": "x", "priority": "urgent"}), 400)]
#[case::priority_wrong_case(json!({"key": "task-a", "title": "t", "body": "x", "priority": "HIGH"}), 400)]
#[case::status_in_progress(json!({"key": "task-a", "title": "t", "body": "x", "status": "in_progress"}), 200)]
#[case::status_blocked_bare(json!({"key": "task-a", "title": "t", "body": "x", "status": "blocked"}), 200)]
#[case::status_blocked_with_reason(json!({"key": "task-a", "title": "t", "body": "x", "status": "blocked", "blocked_reason": "waiting on vendor"}), 200)]
#[case::status_unknown(json!({"key": "task-a", "title": "t", "body": "x", "status": "wip"}), 400)]
#[case::stale_reason_on_open(json!({"key": "task-a", "title": "t", "body": "x", "blocked_reason": "waiting on vendor"}), 400)]
#[case::stale_reason_on_in_progress(json!({"key": "task-a", "title": "t", "body": "x", "status": "in_progress", "blocked_reason": "waiting on vendor"}), 400)]
#[case::stale_reason_on_done(json!({"key": "task-a", "title": "t", "body": "x", "status": "done", "resolution": "shipped", "blocked_reason": "waiting on vendor"}), 400)]
#[case::secret_in_reason(json!({"key": "task-a", "title": "t", "body": "x", "status": "blocked", "blocked_reason": "password: super123secret"}), 400)]
#[case::in_progress_needs_no_resolution(json!({"key": "task-a", "title": "t", "body": "x", "status": "in_progress"}), 200)]
#[case::done_still_needs_resolution(json!({"key": "task-a", "title": "t", "body": "x", "status": "done"}), 400)]
#[case::assignee_absent(json!({"key": "task-a", "title": "t", "body": "x"}), 200)]
#[case::assignee_label(json!({"key": "task-a", "title": "t", "body": "x", "assignee": "agent-a"}), 200)]
#[case::assignee_blank_is_unclaimed(json!({"key": "task-a", "title": "t", "body": "x", "assignee": " "}), 200)]
#[case::assignee_secret(json!({"key": "task-a", "title": "t", "body": "x", "assignee": "password: super123secret"}), 400)]
#[case::parent_absent(json!({"key": "task-a", "title": "t", "body": "x"}), 200)]
#[case::parent_task_key(json!({"key": "task-a", "title": "t", "body": "x", "parent_task": "task-parent"}), 200)]
#[case::parent_not_a_task(json!({"key": "task-a", "title": "t", "body": "x", "parent_task": "nats-streams"}), 400)]
#[case::parent_malformed(json!({"key": "task-a", "title": "t", "body": "x", "parent_task": "task-Bad Key"}), 400)]
#[case::parent_traversal(json!({"key": "task-a", "title": "t", "body": "x", "parent_task": "../task-x"}), 400)]
#[case::parent_self(json!({"key": "task-a", "title": "t", "body": "x", "parent_task": "task-a"}), 400)]
#[tokio::test]
async fn task_validation_matrix(#[case] payload: Value, #[case] expect: u16) {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "POST", "/tasks", Some(payload)).await;
assert_eq!(st.as_u16(), expect, "response: {v}");
}
#[rstest]
#[case::knowledge_priority("/knowledge", json!({"key": "k", "title": "t", "body": "x", "priority": "high"}))]
#[case::knowledge_assignee("/knowledge", json!({"key": "k", "title": "t", "body": "x", "assignee": "agent-a"}))]
#[case::knowledge_parent("/knowledge", json!({"key": "k", "title": "t", "body": "x", "parent_task": "task-x"}))]
#[case::incident_priority("/incidents", json!({"key": "inc-a", "title": "t", "body": "x", "service": "s", "severity": "low", "priority": "high"}))]
#[case::incident_assignee("/incidents", json!({"key": "inc-a", "title": "t", "body": "x", "service": "s", "severity": "low", "assignee": "agent-a"}))]
#[case::incident_parent("/incidents", json!({"key": "inc-a", "title": "t", "body": "x", "service": "s", "severity": "low", "parent_task": "task-x"}))]
#[tokio::test]
async fn task_only_fields_ignored_on_other_kinds(#[case] path: &str, #[case] payload: Value) {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "POST", path, Some(payload)).await;
assert_eq!(st, StatusCode::OK, "{v}");
let key = v["key"].as_str().unwrap().to_string();
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert!(v.get("priority").is_none(), "priority is task-only: {v}");
assert!(v.get("blocked_reason").is_none(), "blocked_reason is task-only: {v}");
assert!(v.get("assignee").is_none(), "assignee is task-only: {v}");
assert!(v.get("parent_task").is_none(), "parent_task is task-only: {v}");
}
#[tokio::test]
async fn tags_endpoint_and_tag_search() {
let (app, _data, _idx) = app_with_tmp();
let post = |k: &str, tags: Value| {
json!({"key": k, "title": "t", "body": "apples and bicycles", "tags": tags})
};
call(&app, "POST", "/knowledge", Some(post("a", json!(["Infra", "nats"])))).await;
call(&app, "POST", "/knowledge", Some(post("b", json!(["infra"])))).await;
call(&app, "POST", "/knowledge", Some(post("c", json!(["kubernetes"])))).await;
let (st, v) = call(&app, "GET", "/tags", None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["count"], 3);
assert_eq!(v["tags"][0]["tag"], "infra");
assert_eq!(v["tags"][0]["count"], 2, "case-folded and counted: {v}");
let (_, v) = call(&app, "GET", "/search?q=kubernetes", None).await;
assert_eq!(v["count"], 1);
assert_eq!(v["hits"][0]["key"], "c");
call(&app, "DELETE", "/knowledge/c", None).await;
let (_, v) = call(&app, "GET", "/tags", None).await;
assert_eq!(v["count"], 2);
}
#[tokio::test]
async fn search_sort_recent() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("older", "shared shared shared"))).await;
call(&app, "POST", "/knowledge", Some(upsert_body("newer", "shared once"))).await;
let (_, v) = call(&app, "GET", "/search?q=shared", None).await;
assert_eq!(v["hits"][0]["key"], "older", "relevance favours the denser match");
let (_, v) = call(&app, "GET", "/search?q=shared&sort=recent", None).await;
assert_eq!(v["hits"][0]["key"], "newer", "recent sort puts the latest first");
let (_, v) = call(&app, "GET", "/search?q=&sort=", None).await;
assert_eq!(v["hits"][0]["key"], "newer", "empty q defaults to recent: {v}");
}
#[tokio::test]
async fn reindex_idempotent() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("a", "one"))).await;
call(&app, "POST", "/knowledge", Some(upsert_body("a", "two"))).await;
call(&app, "POST", "/knowledge", Some(upsert_body("b", "three"))).await;
for _ in 0..3 {
let (_, v) = call(&app, "POST", "/reindex", None).await;
assert_eq!(v["head_docs"], 2);
assert_eq!(v["history_docs"], 3);
}
let (_, v) = call(&app, "GET", "/search?q=two", None).await;
assert_eq!(v["count"], 1, "search must be alive after reindex");
}
#[tokio::test]
async fn api_concurrent_upserts() {
let (app, _data, _idx) = app_with_tmp();
let mut set = tokio::task::JoinSet::new();
for i in 0..10 {
let app = app.clone();
set.spawn(async move {
let body = json!({
"key": format!("key-{i}"),
"title": format!("Entry {i}"),
"body": format!("body {i}"),
});
call(&app, "POST", "/knowledge", Some(body)).await
});
}
while let Some(res) = set.join_next().await {
let (st, v) = res.unwrap();
assert_eq!(st, StatusCode::OK, "{v}");
assert_eq!(v["changed"], true);
}
let (_, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(v["entries"], 10);
let (_, v) = call(&app, "GET", "/search?q=&limit=50", None).await;
assert_eq!(v["count"], 10);
let (_, v) = call(&app, "POST", "/reindex", None).await;
assert_eq!(v["head_docs"], 10);
assert_eq!(v["history_docs"], 10);
}
async fn park_on_writer_lock(
app: &Router,
uri: String,
body: Value,
) -> tokio::task::JoinHandle<(StatusCode, Value)> {
let app = app.clone();
let (started, ready) = tokio::sync::oneshot::channel();
let task = tokio::spawn(async move {
let _ = started.send(());
call(&app, "POST", &uri, Some(body)).await
});
ready.await.expect("the request task must start");
for _ in 0..8 {
tokio::task::yield_now().await;
}
task
}
fn open_task(key: &str) -> Value {
json!({
"key": key, "title": "Rotate the internal TLS certificates",
"body": "They expire in a week.\n\n- [ ] schedule the restart window\n",
"priority": "high", "tags": ["security"],
})
}
#[tokio::test]
async fn concurrent_transitions_keep_the_earlier_update() {
let (app, state, _data, _idx) = app_with_state();
let key = "task-rotate-tls-certs";
let (st, v) = call(&app, "POST", "/tasks", Some(open_task(key))).await;
assert_eq!(st, StatusCode::OK, "{v}");
let guard = state.writer.lock().await;
let claim = park_on_writer_lock(
&app,
format!("/tasks/{key}/transition"),
json!({"status": "in_progress", "assignee": "agent-a"}),
)
.await;
let block = park_on_writer_lock(
&app,
format!("/tasks/{key}/transition"),
json!({"status": "blocked", "blocked_reason": "waiting on the CA"}),
)
.await;
drop(guard);
let (st, claimed) = claim.await.unwrap();
assert_eq!(st, StatusCode::OK, "{claimed}");
let (st, blocked) = block.await.unwrap();
assert_eq!(st, StatusCode::OK, "{blocked}");
assert_eq!(claimed["assignee"], "agent-a");
assert_eq!(blocked["status"], "blocked");
assert_eq!(
blocked["assignee"], "agent-a",
"the second transition read the first one's commit: {blocked}"
);
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["status"], "blocked");
assert_eq!(v["blocked_reason"], "waiting on the CA");
assert_eq!(v["assignee"], "agent-a", "the claim was not overwritten: {v}");
assert_eq!(v["priority"], "high", "untouched metadata survives: {v}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}/history"), None).await;
assert_eq!(
v["versions"].as_array().unwrap().len(),
3,
"create plus both transitions, none dropped: {v}"
);
}
#[tokio::test]
async fn a_close_cannot_archive_a_task_reopened_behind_it() {
let (app, state, _data, _idx) = app_with_state();
let key = "task-rotate-tls-certs";
call(&app, "POST", "/tasks", Some(open_task(key))).await;
let guard = state.writer.lock().await;
let close = park_on_writer_lock(
&app,
format!("/tasks/{key}/resolve"),
json!({"resolution": "Rotated by hand; automation filed separately."}),
)
.await;
let reopen = park_on_writer_lock(
&app,
format!("/tasks/{key}/transition"),
json!({"status": "in_progress", "assignee": "agent-b"}),
)
.await;
drop(guard);
let (st, closed) = close.await.unwrap();
assert_eq!(st, StatusCode::OK, "{closed}");
assert_eq!(closed["archived"], true, "the close archived what it closed: {closed}");
let (st, reopened) = reopen.await.unwrap();
assert_eq!(st, StatusCode::OK, "{reopened}");
assert_eq!(reopened["status"], "in_progress");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["status"], "in_progress");
assert_eq!(v["assignee"], "agent-b");
assert!(v.get("archived").is_none(), "the reopened task is back in the canon: {v}");
assert!(
v["resolution"].as_str().unwrap().contains("Rotated by hand"),
"the recorded outcome survives the reopen: {v}"
);
let (_, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(v["open_tasks"], 1, "work in flight is still counted: {v}");
let (_, v) = call(&app, "GET", "/tasks", None).await;
assert_eq!(v["count"], 1, "and it still lists: {v}");
assert_eq!(v["tasks"][0]["archived"], false);
}
#[tokio::test]
async fn a_close_after_a_reopen_carries_the_reopened_state() {
let (app, state, _data, _idx) = app_with_state();
let key = "task-rotate-tls-certs";
call(&app, "POST", "/tasks", Some(open_task(key))).await;
let guard = state.writer.lock().await;
let reopen = park_on_writer_lock(
&app,
format!("/tasks/{key}/transition"),
json!({"status": "in_progress", "assignee": "agent-b"}),
)
.await;
let close = park_on_writer_lock(
&app,
format!("/tasks/{key}/resolve"),
json!({"resolution": "Rotated by hand; automation filed separately."}),
)
.await;
drop(guard);
let (st, reopened) = reopen.await.unwrap();
assert_eq!(st, StatusCode::OK, "{reopened}");
let (st, closed) = close.await.unwrap();
assert_eq!(st, StatusCode::OK, "{closed}");
assert_eq!(closed["archived"], true, "{closed}");
let (_, v) = call(&app, "GET", &format!("/knowledge/{key}"), None).await;
assert_eq!(v["status"], "done");
assert_eq!(v["archived"], true, "a closed task leaves the tree: {v}");
assert_eq!(
v["assignee"], "agent-b",
"the close committed the claim it never resent: {v}"
);
assert!(v["resolution"].as_str().unwrap().contains("Rotated by hand"), "{v}");
let (_, v) = call(&app, "GET", "/healthz", None).await;
assert_eq!(v["open_tasks"], 0, "{v}");
let (_, v) = call(&app, "GET", "/tasks", None).await;
assert_eq!(v["count"], 0, "closed tasks leave the live listing: {v}");
let (_, v) = call(&app, "GET", "/tasks?all=true", None).await;
assert_eq!(v["count"], 1, "and stay in the record: {v}");
assert_eq!(v["tasks"][0]["assignee"], "agent-b");
}
}
#[cfg(test)]
mod published_claims {
use super::api_tests::*;
use axum::http::StatusCode;
const BLOG: &str = "docs/blog/agent-memory-that-keeps-its-mistakes/index.html";
fn published(rel: &str) -> String {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join(rel);
std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("cannot read {rel}: {e}"))
}
fn claims(rel: &str, phrase: &str) {
assert!(
published(rel).contains(phrase),
"{rel} no longer contains the claim {phrase:?}.\n\
The published text changed but this check did not. Update the claim \
and its check together, or the gate stops guarding anything."
);
}
#[tokio::test]
async fn the_post_promises_three_temporal_questions_and_gets_them() {
claims(BLOG, "<code>--as-of</code> gives the base as");
claims(BLOG, "<code>--changed-between</code> gives what moved inside a window");
claims(BLOG, "<code>/diff</code> says what moved <em>inside</em> one");
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "the port is 8080"))).await;
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "the port is 9090"))).await;
let (st, v) = call(&app, "GET", "/search?q=port&as_of=2999-01-01", None).await;
assert_eq!(st, StatusCode::OK, "the post promises --as-of");
assert_eq!(v["count"], 1, "as_of returns one version per key, as the post says");
let (st, v) =
call(&app, "GET", "/search?q=port&changed_between=2000-01-01,2999-01-01", None).await;
assert_eq!(st, StatusCode::OK, "the post promises --changed-between");
assert_eq!(v["count"], 1);
let (st, v) = call(&app, "GET", "/knowledge/svc/diff", None).await;
assert_eq!(st, StatusCode::OK, "the post promises /diff");
assert_eq!(v["changed"], true);
}
#[test]
fn the_post_says_the_temporal_questions_are_lexical_and_the_guard_is_still_there() {
claims(BLOG, "All three are lexical");
claims(BLOG, "one vector per key,");
let src = published("src/main.rs");
let guard = src
.split("let want_semantic")
.nth(1)
.and_then(|tail| tail.split(';').next())
.unwrap_or_default()
.to_string();
for needed in ["!history", "as_of.is_none()", "window.is_none()"] {
assert!(
guard.contains(needed),
"want_semantic no longer excludes {needed}, so a versioned query can now be \
answered semantically - which makes {BLOG} wrong where it says the temporal \
questions are lexical. Update both together."
);
}
}
#[tokio::test]
async fn the_post_states_the_second_granularity_limit() {
claims(BLOG, "two versions written inside the same
second cannot be told apart");
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "value one"))).await;
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "value two"))).await;
let (_, h) = call(&app, "GET", "/knowledge/svc/history", None).await;
let older = h["versions"][1]["sha"].as_str().unwrap().to_string();
let (st, v) = call(&app, "GET", &format!("/search?q=value&as_of={older}"), None).await;
assert_eq!(st, StatusCode::OK);
assert_eq!(v["count"], 1, "one row per key even when the bound cannot separate versions");
}
#[tokio::test]
async fn every_advertised_capability_is_backed_and_gated() {
let (app, _data, _idx) = app_with_tmp();
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "one"))).await;
call(&app, "POST", "/knowledge", Some(upsert_body("svc", "two"))).await;
let probes = [
("as_of", "/search?q=one&as_of=2999-01-01"),
("changed_between", "/search?q=one&changed_between=2000-01-01,2999-01-01"),
("diff", "/knowledge/svc/diff"),
];
assert_eq!(probes.len(), super::CAPABILITIES.len(), "a capability was added without a probe");
let cli = published("skills/kyb/bin/kyb");
for (cap, uri) in probes {
assert!(super::CAPABILITIES.contains(&cap), "{cap} is probed but not advertised");
let (st, v) = call(&app, "GET", uri, None).await;
assert_eq!(st, StatusCode::OK, "advertised {cap} but {uri} answered {st}: {v}");
assert!(
cli.contains(&format!("require_capability {cap} ")),
"the CLI does not gate {cap}, so it would send it to a server that cannot honour it"
);
}
}
#[tokio::test]
async fn the_skill_and_readme_document_commands_that_exist() {
for doc in ["README.md", "skills/kyb/SKILL.md"] {
claims(doc, "--as-of");
claims(doc, "--changed-between");
claims(doc, "kyb diff");
}
let cli = published("skills/kyb/bin/kyb");
for flag in ["--as-of", "--changed-between"] {
assert!(cli.contains(flag), "the docs promise {flag} but the CLI does not parse it");
}
assert!(cli.contains(" diff)"), "the docs promise `kyb diff` but the CLI has no such verb");
}
#[tokio::test]
async fn web_ui_served_at_root() {
let (app, _data, _idx) = app_with_tmp();
let req = axum::http::Request::builder().uri("/").body(axum::body::Body::empty()).unwrap();
let resp = tower::ServiceExt::oneshot(app.clone(), req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
let ctype = resp.headers().get("content-type").unwrap().to_str().unwrap();
assert!(ctype.contains("text/html"), "expected text/html, got {ctype}");
let bytes = http_body_util::BodyExt::collect(resp.into_body()).await.unwrap().to_bytes();
let body_str = String::from_utf8_lossy(&bytes);
assert!(body_str.contains("KYB — Fleet Memory & Control Room"));
assert!(body_str.contains("placesList"));
}
#[tokio::test]
async fn api_audit_returns_entries() {
let (app, _data, _idx) = app_with_tmp();
let (st, v) = call(&app, "GET", "/api/audit", None).await;
assert_eq!(st, StatusCode::OK);
assert!(v.get("entries").is_some());
assert!(v.get("count").is_some());
}
}