second-brain-cli 0.13.5

Memory layer for AI coding agents: ingest, recall, and sync across machines
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}");
}