mod common;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::{Command, Output, Stdio};
use std::time::Duration;
use common::{Answer, Home, LIMIT, assert_silent as assert_allowed, closed_port, daemon, run_hook};
use second_brain_core::keys::DeviceKeys;
use second_brain_core::write_queue::Entry;
use serde_json::{Value, json};
const SESSION: &str = "5b0c2f9e-3d41-4f6a-9c1e-7a2b8d4e6f10";
fn no_notes() -> Answer {
Answer::Json(json!({"notes": []}).to_string())
}
fn one_note() -> Answer {
Answer::Json(
json!({"notes": [{
"id": "0d6f3c1a-8b9e-4f2d-a7c5-1e3b5d7f9a20",
"kind": "session-end",
"decision": "kept the parser",
"reason": "",
"dead_ends": [],
"open_items": [],
"blocked_on_user": [],
"session_id": SESSION,
"project": null,
"session_at": null,
"created_at": "2026-11-02T10:00:00Z"
}]})
.to_string(),
)
}
fn tool_line(id: &str, name: &str, sidechain: bool) -> String {
json!({
"type": "assistant",
"isSidechain": sidechain,
"sessionId": SESSION,
"message": {
"role": "assistant",
"content": [{"type": "tool_use", "id": id, "name": name, "input": {}}]
}
})
.to_string()
}
fn result_line(id: &str) -> String {
json!({
"type": "user",
"isSidechain": false,
"message": {
"role": "user",
"content": [{"type": "tool_result", "tool_use_id": id, "content": "ok"}]
}
})
.to_string()
}
fn transcript(calls: &[(&str, bool)]) -> Vec<String> {
let mut lines = vec![
json!({"type": "user", "message": {"role": "user", "content": "do the thing"}}).to_string(),
];
for (n, (name, sidechain)) in calls.iter().enumerate() {
let id = format!("toolu_{n:04}");
lines.push(tool_line(&id, name, *sidechain));
lines.push(tool_line(&id, name, *sidechain));
lines.push(result_line(&id));
}
lines
}
fn substantive() -> Vec<String> {
transcript(&[("Read", false), ("Edit", false)])
}
trait Transcripts {
fn transcript(&self, lines: &[String]) -> PathBuf;
fn queue(&self, name: &str, entry: Value);
}
impl Transcripts for Home {
fn transcript(&self, lines: &[String]) -> PathBuf {
let path = self.path().join("transcript.jsonl");
std::fs::write(&path, lines.join("\n") + "\n").unwrap();
path
}
fn queue(&self, name: &str, entry: Value) {
let dir = self.path().join(".second-brain/queue");
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join(name), entry.to_string()).unwrap();
}
}
fn stop_input(transcript: &Path, active: bool) -> String {
json!({
"session_id": SESSION,
"transcript_path": transcript,
"cwd": "/tmp/project",
"permission_mode": "default",
"hook_event_name": "Stop",
"stop_hook_active": active,
"last_assistant_message": "done"
})
.to_string()
}
fn run(home: &Home, api: &str, stdin: &str) -> (Output, Duration) {
run_hook(home, api, "stop", stdin)
}
fn queued_note(session_id: &str, kind: Option<&str>) -> Value {
let mut body = json!({"session_id": session_id, "decision": "kept the parser"});
if let Some(kind) = kind {
body["kind"] = json!(kind);
}
json!({"tool": "note", "method": "POST", "path": "/v1/notes", "query": null, "body": body})
}
#[test]
fn an_active_stop_hook_allows_without_asking_the_daemon() {
let home = Home::new();
let transcript = home.transcript(&substantive());
let daemon = daemon(no_notes());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, true));
assert_allowed(&output);
assert!(daemon.requests().is_empty());
}
#[test]
fn a_trivial_transcript_allows_without_asking_the_daemon() {
let home = Home::new();
let transcript = home.transcript(&transcript(&[("Bash", false), ("Bash", false)]));
let daemon = daemon(no_notes());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
assert_allowed(&output);
assert!(daemon.requests().is_empty());
}
#[test]
fn substantive_work_with_a_stored_note_allows() {
let home = Home::new();
let transcript = home.transcript(&substantive());
let daemon = daemon(one_note());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
assert_allowed(&output);
assert_eq!(daemon.requests().len(), 1);
}
#[test]
fn substantive_work_without_a_note_blocks_and_names_the_session() {
let home = Home::new();
let calls: Vec<(&str, bool)> = std::iter::repeat_n(("Bash", false), 10).collect();
let transcript = home.transcript(&transcript(&calls));
let daemon = daemon(no_notes());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
assert_eq!(output.status.code(), Some(0), "{output:?}");
let reply: Value = serde_json::from_slice(&output.stdout).unwrap();
assert_eq!(reply["decision"], "block", "{reply}");
let reason = reply["reason"].as_str().unwrap();
assert!(reason.contains(SESSION), "{reason}");
assert!(reason.contains("`note`"), "{reason}");
assert!(reason.contains("session-end"), "{reason}");
let requests = daemon.requests();
assert_eq!(requests.len(), 1, "{requests:?}");
let request_line = requests[0].head.lines().next().unwrap();
assert!(request_line.starts_with("get /v1/notes?"), "{request_line}");
assert!(
request_line.contains(&format!("session_id={SESSION}")),
"{request_line}"
);
assert!(request_line.contains("kind=session-end"), "{request_line}");
let bearer = format!("authorization: bearer {}", "t".repeat(32));
assert!(requests[0].head.contains(&bearer), "{}", requests[0].head);
}
#[test]
fn nine_calls_without_an_edit_are_not_substantive() {
let home = Home::new();
let calls: Vec<(&str, bool)> = std::iter::repeat_n(("Bash", false), 9).collect();
let transcript = home.transcript(&transcript(&calls));
let daemon = daemon(no_notes());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
assert_allowed(&output);
assert!(daemon.requests().is_empty());
}
#[test]
fn a_queued_note_for_the_session_allows_without_asking_the_daemon() {
let home = Home::new();
home.queue(
"1762077600000000000-6f1c9a2e-4b3d-4e5f-8a7b-9c0d1e2f3a4b.json",
queued_note(SESSION, None),
);
let transcript = home.transcript(&substantive());
let daemon = daemon(no_notes());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
assert_allowed(&output);
assert!(daemon.requests().is_empty());
}
#[test]
fn queued_notes_for_other_sessions_kinds_or_names_do_not_count() {
let home = Home::new();
home.queue(
"1762077600000000001-6f1c9a2e-4b3d-4e5f-8a7b-9c0d1e2f3a4b.json",
queued_note("another-session", Some("session-end")),
);
home.queue(
"1762077600000000002-7f1c9a2e-4b3d-4e5f-8a7b-9c0d1e2f3a4b.json",
queued_note(SESSION, Some("decision")),
);
home.queue("pending-note.json", queued_note(SESSION, None));
let transcript = home.transcript(&substantive());
let daemon = daemon(no_notes());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
let reply: Value = serde_json::from_slice(&output.stdout).unwrap();
assert_eq!(reply["decision"], "block", "{reply}");
assert_eq!(daemon.requests().len(), 1);
}
fn sealed(entry: Value) -> Value {
let entry: Entry = serde_json::from_value(entry).unwrap();
let recipient = DeviceKeys::generate().unwrap().age_recipient();
serde_json::from_slice(&entry.to_sealed_file(&[recipient]).unwrap()).unwrap()
}
#[test]
fn a_sealed_queued_note_for_the_session_allows_without_asking_the_daemon() {
let home = Home::new();
let note = sealed(queued_note(SESSION, Some("session-end")));
assert!(note.get("body").is_none(), "{note}");
home.queue(
"1762077600000000000-6f1c9a2e-4b3d-4e5f-8a7b-9c0d1e2f3a4b.sealed",
note,
);
let transcript = home.transcript(&substantive());
let daemon = daemon(no_notes());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
assert_allowed(&output);
assert!(daemon.requests().is_empty());
}
#[test]
fn sealed_queued_notes_for_other_sessions_or_kinds_do_not_count() {
let home = Home::new();
home.queue(
"1762077600000000001-6f1c9a2e-4b3d-4e5f-8a7b-9c0d1e2f3a4b.sealed",
sealed(queued_note("another-session", None)),
);
home.queue(
"1762077600000000002-7f1c9a2e-4b3d-4e5f-8a7b-9c0d1e2f3a4b.sealed",
sealed(queued_note(SESSION, Some("decision"))),
);
let transcript = home.transcript(&substantive());
let daemon = daemon(no_notes());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
let reply: Value = serde_json::from_slice(&output.stdout).unwrap();
assert_eq!(reply["decision"], "block", "{reply}");
assert_eq!(daemon.requests().len(), 1);
}
#[test]
fn a_daemon_that_is_down_allows_in_time() {
let home = Home::new();
let transcript = home.transcript(&substantive());
let (output, took) = run(&home, &closed_port(), &stop_input(&transcript, false));
assert_allowed(&output);
assert!(took < LIMIT, "{took:?}");
}
#[test]
fn a_starting_daemon_allows_in_time_and_does_not_count_as_asked() {
let home = Home::new();
let transcript = home.transcript(&substantive());
let starting = daemon(Answer::Routed(common::starting));
let (output, took) = run(&home, &starting.base, &stop_input(&transcript, false));
assert_allowed(&output);
assert_eq!(String::from_utf8_lossy(&output.stderr), "", "{output:?}");
assert!(took < LIMIT, "{took:?}");
assert_eq!(starting.requests().len(), 1);
let ready = daemon(no_notes());
let (output, _) = run(&home, &ready.base, &stop_input(&transcript, false));
let reply: Value = serde_json::from_slice(&output.stdout).unwrap();
assert_eq!(reply["decision"], "block", "{reply}");
}
#[test]
fn a_daemon_that_never_answers_allows_in_time() {
let home = Home::new();
let transcript = home.transcript(&substantive());
let daemon = daemon(Answer::Never);
let (output, took) = run(&home, &daemon.base, &stop_input(&transcript, false));
assert_allowed(&output);
assert!(took < LIMIT, "{took:?}");
assert_eq!(daemon.requests().len(), 1);
}
#[test]
fn malformed_stdin_allows() {
let home = Home::new();
let daemon = daemon(no_notes());
for stdin in ["", "not json", "{\"session_id\": 5}", "[]"] {
let (output, _) = run(&home, &daemon.base, stdin);
assert_allowed(&output);
}
assert!(daemon.requests().is_empty());
}
#[test]
fn edits_made_only_by_subagents_do_not_count() {
let home = Home::new();
let calls: Vec<(&str, bool)> = [("Read", false)]
.into_iter()
.chain(std::iter::repeat_n(("Edit", true), 12))
.collect();
let transcript = home.transcript(&transcript(&calls));
let daemon = daemon(no_notes());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
assert_allowed(&output);
assert!(daemon.requests().is_empty());
}
#[test]
fn a_missing_transcript_allows() {
let home = Home::new();
let daemon = daemon(no_notes());
let missing = home.path().join("gone.jsonl");
let (output, _) = run(&home, &daemon.base, &stop_input(&missing, false));
assert_allowed(&output);
assert!(daemon.requests().is_empty());
}
#[test]
fn an_unknown_hook_name_allows() {
let home = Home::new();
let mut child = Command::new(env!("CARGO_BIN_EXE_sb"))
.args(["hook", "no-such-event"])
.env("HOME", home.path())
.env("SECOND_BRAIN_API", closed_port())
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.unwrap();
child.stdin.take().unwrap().write_all(b"{}").unwrap();
assert_allowed(&child.wait_with_output().unwrap());
}
#[test]
fn a_session_is_asked_for_its_note_only_once() {
let home = Home::new();
let transcript = home.transcript(&substantive());
let daemon = daemon(no_notes());
let (first, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
let reply: Value = serde_json::from_slice(&first.stdout).unwrap();
assert_eq!(reply["decision"], "block", "{reply}");
let (later_turn, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
assert_allowed(&later_turn);
assert_eq!(daemon.requests().len(), 1);
}
#[test]
fn another_session_is_still_asked_after_one_was() {
let home = Home::new();
let transcript = home.transcript(&substantive());
let daemon = daemon(no_notes());
run(&home, &daemon.base, &stop_input(&transcript, false));
let mut other: Value = serde_json::from_str(&stop_input(&transcript, false)).unwrap();
other["session_id"] = json!("8c1d3e5f-7a9b-4c2d-8e0f-1a3b5c7d9e21");
let (output, _) = run(&home, &daemon.base, &other.to_string());
let reply: Value = serde_json::from_slice(&output.stdout).unwrap();
assert_eq!(reply["decision"], "block", "{reply}");
}
#[test]
fn a_stop_the_daemon_could_not_answer_does_not_count_as_asked() {
let home = Home::new();
let transcript = home.transcript(&substantive());
let (down, _) = run(&home, &closed_port(), &stop_input(&transcript, false));
assert_allowed(&down);
let daemon = daemon(no_notes());
let (output, _) = run(&home, &daemon.base, &stop_input(&transcript, false));
let reply: Value = serde_json::from_slice(&output.stdout).unwrap();
assert_eq!(reply["decision"], "block", "{reply}");
}