mod audit;
mod config;
mod embed;
mod index;
mod model;
mod store;
use anyhow::Result;
use axum::extract::{Path, Query, State};
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>,
}
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>> {
let store = store::Store::open(&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 semantic = match embed::Semantic::load(&cfg.model_dir) {
Ok(s) => {
eprintln!("kyb: semantic search on ({})", cfg.model_dir.display());
Some(s)
}
Err(e) => {
eprintln!("kyb: lexical-only search ({e})");
None
}
};
Ok(Arc::new(AppState { store, index, audit, semantic, writer: Mutex::new(writer) }))
}
fn build_app(state: Arc<AppState>) -> Router {
Router::new()
.route("/healthz", get(healthz))
.route("/knowledge", post(upsert))
.route("/knowledge/{key}", get(get_one).delete(remove))
.route("/knowledge/{key}/history", get(history))
.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(), audit::audit_mw))
.with_state(state)
}
#[tokio::main]
async fn main() -> Result<()> {
let cfg = config::Config::from_env();
let state = build_state(&cfg)?;
rebuild_vectors(&state).await;
let app = build_app(state);
let listener = tokio::net::TcpListener::bind(&cfg.addr).await?;
eprintln!("kyb: listening on http://{}", cfg.addr);
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:#}")})))
}
#[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();
let (mut reply, committed) = commit_locked(st, &mut w, entry, extra);
if closed {
archive_locked(st, &mut w, &key, &mut reply);
}
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 (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 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)]
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)) => {
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)]
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(200));
Ok(rows)
}
fn is_archived(st: &AppState, key: &str) -> bool {
!matches!(st.store.get(key), Ok(Some(_)))
}
async fn list_incidents(State(st): St, Query(q): Query<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, Query(q): Query<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)]
struct GetQ {
at: Option<String>,
}
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>, Query(q): Query<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.store.latest_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}'")})))
}
}
}
async fn history(State(st): St, Path(key): Path<String>) -> Reply {
if let Some(r) = bad_key(&key) {
return r;
}
match st.store.history(&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}))),
}
}
#[derive(Deserialize)]
struct SearchQ {
q: Option<String>,
tag: Option<String>,
history: Option<bool>,
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, Query(p): Query<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 want_semantic =
!recent && !history && !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,
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 {
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(&mut w, &key);
if let Err(e) = st.index.commit_and_reload(&mut 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;
}
drop(w);
(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)) => {
(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})))
}
}
}
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})),
})),
)
}
#[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;
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)
}
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(&cfg).unwrap();
(build_app(state.clone()), state, data, idx)
}
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 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", &format!("/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_eq!(v["hits"][0]["resolution"].as_str().unwrap().contains("2G"), true);
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");
}
}