From 5507ec9b71b46507a0ca455020e8fc67de382868 Mon Sep 17 00:00:00 2001 From: javis-bot Date: Thu, 12 Nov 2026 09:58:55 +0900 Subject: [PATCH] test(app): time the whole conversation on real Discord, alone and with 9 more voices live_round_trip.rs runs the app's services with the real worker and brain, plays recorded questions from a second bot and times the final, the answer text, playback start and the first audible frame after the speech ends; a second worker session streams nine more voices for the load run. Roadmap: first M4 step 4 numbers (median 3.5 s alone, 4.4 s under load). Co-Authored-By: Claude Opus 5.5 --- app/tests/live_round_trip.rs | 354 +++++++++++++++++++++++++++++++++++ docs/v2/roadmap.md | 2 +- 2 files changed, 355 insertions(+), 1 deletion(-) create mode 100644 app/tests/live_round_trip.rs diff --git a/app/tests/live_round_trip.rs b/app/tests/live_round_trip.rs new file mode 100644 index 0000000..9a50e34 --- /dev/null +++ b/app/tests/live_round_trip.rs @@ -0,0 +1,354 @@ +//! M4 step 4: the whole conversation on real Discord, timed from the end of a question to Jarvis's +//! first sound, with the real voice worker, the real brain (Strata) and the real response policy. +//! +//! The "speaker" bot plays recorded Korean questions that call Jarvis into the voice channel and +//! listens for the answer. The Jarvis bot runs the app's services (`start_services`: core, +//! conversation loop, worker process). Each question is timed at four points after the speech ends: +//! the final transcript, the brain's answer text, playback start and the first audible frame the +//! speaker bot receives. The rounds run again while nine more voices talk at the same time (a second +//! worker session feeding the shared STT), which is the 10-person load. +//! Opt-in; it refuses to run if a person is in the channel or either bot is already in voice. +//! +//! JARVIS_LIVE_ROUND_TRIP=1 JARVIS_LIVE_BOT_TOKEN=... JARVIS_LIVE_SPEAKER_TOKEN=... \ +//! JARVIS_LIVE_GUILD= JARVIS_LIVE_VOICE_CHANNEL= \ +//! JARVIS_VOICE_PYTHON= JARVIS_MELO_PYTHON= \ +//! JARVIS_CONFIG_PATH= \ +//! JARVIS_LIVE_QUESTIONS= [JARVIS_LIVE_ROUNDS=2] \ +//! cargo test --release --test live_round_trip -- --nocapture +//! +//! On Linux, put the pip CUDA libraries on LD_LIBRARY_PATH (nvidia/cublas/lib, nvidia/cudnn/lib). + +use std::collections::HashMap; +use std::path::{Path, PathBuf}; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::{Arc, Mutex}; +use std::time::{Duration, Instant}; + +use async_trait::async_trait; +use jarvis_app::discord::CoreEvent; +use jarvis_app::receive::{opus_payload, OpusFrames, SpeakerStream}; +use jarvis_app::services::start_services; +use jarvis_app::worker_client::{WorkerClient, WorkerClientOptions}; +use serde_json::{json, Value}; +use serenity::all::{ChannelId, Client, Context, EventHandler, GatewayIntents, GuildId, Ready, UserId}; +use songbird::driver::DecodeMode; +use songbird::input::Input; +use songbird::{Config, CoreEvent as VoiceEv, Event, EventContext, EventHandler as VoiceHandler, SerenityInit, Songbird}; +use tokio::sync::mpsc; + +fn env(k: &str) -> String { + std::env::var(k).unwrap_or_else(|_| panic!("{k} is not set")) +} + +/// Seconds from the start of a 16 kHz mono PCM16 wav to its last sample above -34 dBFS. +fn speech_end_seconds(wav: &[u8]) -> f64 { + let data = &wav[44..]; + let n = data.len() / 2; + (0..n).rev().find(|&k| i16::from_le_bytes([data[2 * k], data[2 * k + 1]]).unsigned_abs() > 655) + .map_or(0.0, |k| (k + 1) as f64 / 16000.0) +} + +fn wav_samples(wav: &[u8]) -> Vec { + wav[44..].chunks_exact(2).map(|b| i16::from_le_bytes([b[0], b[1]])).collect() +} + +struct HeardText { + text: String, + stt_ms: u64, +} + +struct ReadyOnce(mpsc::UnboundedSender); +#[async_trait] +impl EventHandler for ReadyOnce { + async fn ready(&self, _: Context, r: Ready) { + let _ = self.0.send(r); + } +} + +/// When Jarvis's voice first becomes audible to the speaker bot, decoded the way the core decodes +/// (songbird's own decoder garbles DAVE audio, see src/receive.rs). +#[derive(Clone, Default)] +struct Ears { + jarvis: u64, + ssrc: Arc>>, + stream: Arc>>>, + first_audible: Arc>>, +} + +#[async_trait] +impl VoiceHandler for Ears { + async fn act(&self, ctx: &EventContext<'_>) -> Option { + match ctx { + EventContext::SpeakingStateUpdate(s) => { + if let Some(u) = s.user_id { + self.ssrc.lock().unwrap().insert(s.ssrc, u.0); + } + } + EventContext::RtpPacket(p) => { + let (seq, ssrc, opus) = opus_payload(&p.packet, p.payload_offset, p.payload_end_pad)?; + if self.ssrc.lock().unwrap().get(&ssrc) != Some(&self.jarvis) { + return None; + } + let frames = self.stream.lock().unwrap().get_or_insert_with(|| SpeakerStream::new(OpusFrames::new())) + .push(seq, opus.to_vec()); + for f in frames { + // Audible: louder than -36 dBFS. Silence frames do not count. + let rms = (f.iter().map(|&x| f64::from(x).powi(2)).sum::() / f.len().max(1) as f64).sqrt(); + if rms > 500.0 { + self.first_audible.lock().unwrap().get_or_insert_with(Instant::now); + } + } + } + _ => {} + } + None + } +} + +async fn until(what: &str, ms: u64, mut pred: impl FnMut() -> bool) { + let deadline = Instant::now() + Duration::from_millis(ms); + while !pred() { + assert!(Instant::now() < deadline, "timed out waiting for {what}"); + tokio::time::sleep(Duration::from_millis(10)).await; + } +} + +/// Nine more voices: a second worker session streams recorded sentences for nine speakers in real +/// time, all talking at once with short pauses, until `stop` is set. +fn background_voices(url: String, token: String, samples: Vec>, stop: Arc) -> tokio::task::JoinHandle { + tokio::spawn(async move { + let mut o = WorkerClientOptions::new(url, token); + o.stt = json!({"partials": true}).as_object().unwrap().clone(); + let (load, mut rx) = WorkerClient::new(o); + load.start(); + load.wait_ready(Duration::from_secs(10)).await.expect("load session hello"); + let finals = Arc::new(Mutex::new(0u64)); + let f2 = finals.clone(); + tokio::spawn(async move { + while let Some(e) = rx.recv().await { + if matches!(e, jarvis_app::worker_client::WorkerEvent::Final(_)) { + *f2.lock().unwrap() += 1; + } + } + }); + // 20 ms of 48 kHz stereo per frame, the format the core sends. + let mut pos: Vec<(usize, usize, usize)> = (0..9).map(|i| (i % samples.len(), i * 4000, 0)).collect(); + let mut tick = tokio::time::interval(Duration::from_millis(20)); + while !stop.load(Ordering::Relaxed) { + tick.tick().await; + for (i, (sample, at, pause)) in pos.iter_mut().enumerate() { + let speaker = format!("load-{i}"); + if *pause > 0 { + *pause -= 1; + if *pause == 0 { + load.speaking_end(&speaker); + } + continue; + } + let s = &samples[*sample]; + let end = (*at + 320).min(s.len()); + let frame: Vec = s[*at..end].iter().flat_map(|&x| [x; 6]).collect(); + load.send_audio(&speaker, &frame); + *at = end; + if end == s.len() { + *sample = (*sample + 1) % samples.len(); + *at = 0; + *pause = 25 + i * 3; // 0.5-1 s apart, staggered + } + } + } + load.close(); + let n = *finals.lock().unwrap(); + n + }) +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn conversation_round_trip_on_real_discord() { + if std::env::var("JARVIS_LIVE_ROUND_TRIP").as_deref() != Ok("1") { + eprintln!("skipped: set JARVIS_LIVE_ROUND_TRIP=1"); + return; + } + let guild: u64 = env("JARVIS_LIVE_GUILD").parse().unwrap(); + let voice: u64 = env("JARVIS_LIVE_VOICE_CHANNEL").parse().unwrap(); + let rounds: usize = std::env::var("JARVIS_LIVE_ROUNDS").ok().and_then(|v| v.parse().ok()).unwrap_or(2); + let questions = PathBuf::from(env("JARVIS_LIVE_QUESTIONS")); + env("JARVIS_CONFIG_PATH"); // the worker's brain reads it + let root = Path::new(env!("CARGO_MANIFEST_DIR")); + + // The speaker bot first: it checks the channel is free before anything joins. + let speaker_songbird = Songbird::serenity_from_config(Config::default().decode_mode(DecodeMode::Decrypt)); + let (rtx, mut rrx) = mpsc::unbounded_channel(); + let mut speaker = Client::builder(env("JARVIS_LIVE_SPEAKER_TOKEN"), GatewayIntents::GUILDS | GatewayIntents::GUILD_VOICE_STATES) + .event_handler(ReadyOnce(rtx)).register_songbird_with(speaker_songbird.clone()).await.unwrap(); + let (s_cache, s_shards) = (speaker.cache.clone(), speaker.shard_manager.clone()); + tokio::spawn(async move { speaker.start().await.unwrap() }); + let speaker_id = rrx.recv().await.unwrap().user.id.get(); + let bot_token = env("JARVIS_LIVE_BOT_TOKEN"); + let jarvis_app_id = serenity::all::Http::new(&bot_token).get_current_application_info().await.unwrap().id.get(); + until("guild in cache", 10_000, || s_cache.guild(GuildId::new(guild)).is_some()).await; + { + let g = s_cache.guild(GuildId::new(guild)).unwrap(); + let people = g.voice_states.values().filter(|v| v.channel_id.is_some_and(|c| c.get() == voice) + && !s_cache.user(v.user_id).map(|u| u.bot).unwrap_or(false)).count(); + assert_eq!(people, 0, "refusing to test: people are in the voice channel"); + for id in [speaker_id, jarvis_app_id] { + assert!(g.voice_states.get(&UserId::new(id)).and_then(|v| v.channel_id).is_none(), + "refusing to test: bot {id} is in a voice channel"); + } + } + + // The app's services, as the app starts them, from a fresh data folder. + let data = Path::new(env!("CARGO_TARGET_TMPDIR")).join(format!("live-round-trip-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&data); + std::fs::create_dir_all(data.join("config")).unwrap(); + let mut args = vec!["--history".to_string(), data.join("history.sqlite").to_string_lossy().into_owned(), "--brain".into()]; + if let Ok(m) = std::env::var("JARVIS_MELO_PYTHON") { + args.extend(["--melo-python".to_string(), m]); + } + std::fs::write(data.join("config").join("settings.json"), serde_json::to_string_pretty(&json!({ + "discord": {"guildId": guild.to_string(), "voiceChannelId": voice.to_string()}, + // The "person" here is a bot, so bots must be heard. + "voice": {"listenToBots": true}, + "voiceWorker": {"python": env("JARVIS_VOICE_PYTHON"), "cwd": root.join("../src"), "args": args}, + })).unwrap()).unwrap(); + std::env::set_var("JARVIS_DISCORD_TOKEN", &bot_token); + let services = tokio::time::timeout(Duration::from_secs(300), start_services(&data)).await + .expect("services start in time").expect("services start"); + services.worker.wait_ready(Duration::from_secs(240)).await.expect("worker ready"); + let core = services.core.clone(); + let events: Arc>> = Arc::default(); + let ev2 = events.clone(); + let mut rx = services.events; + tokio::spawn(async move { + while let Some(e) = rx.recv().await { + ev2.lock().unwrap().push((Instant::now(), e)); + } + }); + until("Jarvis in voice", 20_000, || core.voice_channel_id() == Some(voice)).await; + let jarvis = core.bot_id().unwrap(); + + let call = speaker_songbird.join(GuildId::new(guild), ChannelId::new(voice)).await.expect("speaker joins"); + let ears = Ears { jarvis, ..Default::default() }; + { + let mut c = call.lock().await; + c.add_global_event(VoiceEv::SpeakingStateUpdate.into(), ears.clone()); + c.add_global_event(VoiceEv::RtpPacket.into(), ears.clone()); + } + tokio::time::sleep(Duration::from_secs(2)).await; // the DAVE group settles after the join + + let refs: Value = serde_json::from_str(&std::fs::read_to_string(questions.join("refs.json")).unwrap()).unwrap(); + let qs: Vec<(String, Vec)> = refs["samples"].as_array().unwrap().iter() + .map(|r| (r["text"].as_str().unwrap().to_owned(), std::fs::read(questions.join(r["file"].as_str().unwrap())).unwrap())) + .collect(); + let load_samples: Vec> = std::fs::read_dir(root.join("../scripts/m0/assets/ko_samples")).unwrap() + .filter_map(|e| e.ok().map(|e| e.path())).filter(|p| p.extension().is_some_and(|x| x == "wav")) + .map(|p| wav_samples(&std::fs::read(p).unwrap())).collect(); + + let mut report = serde_json::Map::new(); + let steps = futures_util::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async { + for phase in ["alone", "with_9_more_voices"] { + let stop = Arc::new(AtomicBool::new(false)); + let load = (phase != "alone").then(|| { + background_voices(services.worker_process.url(), services.worker_process.token.clone(), load_samples.clone(), stop.clone()) + }); + if load.is_some() { + tokio::time::sleep(Duration::from_secs(3)).await; + } + let mut rows = vec![]; + for round in 0..rounds { + for (text, wav) in &qs { + // The previous answer is over before the next question. + until("Jarvis to finish speaking", 60_000, || !core.speaking()).await; + let before = events.lock().unwrap().len(); + *ears.first_audible.lock().unwrap() = None; + let track = call.lock().await.play_only_input(Input::from(wav.clone())); + let deadline = Instant::now() + Duration::from_secs(5); + let started = loop { + if track.get_info().await.is_ok_and(|i| i.position > Duration::ZERO) { + break Instant::now(); + } + assert!(Instant::now() < deadline, "timed out waiting for the track to play"); + tokio::time::sleep(Duration::from_millis(5)).await; + }; + let speech_end = started + Duration::from_secs_f64(speech_end_seconds(wav)); + // The answer is over when its own playback ends (or nothing came for 30 s). + let finished = tokio::time::timeout(Duration::from_secs(30), async { + loop { + { + let ev = events.lock().unwrap(); + let id = ev[before..].iter().find_map(|(_, e)| match e { + CoreEvent::ReplyText { id, .. } => Some(id.clone()), + _ => None, + }); + if id.is_some_and(|id| ev[before..].iter().any(|(_, e)| matches!(e, CoreEvent::SpeakEnd(x) if x.id == id))) { + return; + } + } + tokio::time::sleep(Duration::from_millis(20)).await; + } + }).await.is_ok(); + let ev = events.lock().unwrap()[before..].to_vec(); + let ms = |t: Option| t.map(|t| t.saturating_duration_since(speech_end).as_millis() as i64); + let reply = ev.iter().find_map(|(t, e)| match e { + CoreEvent::ReplyText { text, failed, .. } => Some((*t, text.clone(), *failed)), + _ => None, + }); + // A question may be heard as several finals (a pause after the wake word): all of + // them are what was heard, and the last one before the answer is the one timed. + let finals: Vec<_> = ev.iter().filter_map(|(t, e)| match e { + CoreEvent::Final(f) if f.heard.speaker_id == speaker_id && !f.text.is_empty() + && reply.as_ref().is_none_or(|r| *t <= r.0) => Some((*t, f.clone())), + _ => None, + }).collect(); + let final_ev = finals.last().map(|(t, f)| (*t, HeardText { + text: finals.iter().map(|(_, f)| f.text.as_str()).collect::>().join(" | "), + stt_ms: f.stt_ms, + })); + let speak_start = ev.iter().find_map(|(t, e)| matches!(e, CoreEvent::SpeakStart(_)).then_some(*t)); + let first_sound = *ears.first_audible.lock().unwrap(); + rows.push(json!({ + "round": round, "question": text, + "heard": final_ev.as_ref().map(|(_, f)| f.text.clone()), + "stt_ms": final_ev.as_ref().map(|(_, f)| f.stt_ms), + "answer": reply.as_ref().map(|r| r.1.clone()), + "final_ms": ms(final_ev.as_ref().map(|f| f.0)), + "answer_text_ms": ms(reply.as_ref().map(|r| r.0)), + "speak_start_ms": ms(speak_start), + "first_sound_ms": ms(first_sound), + "spoken": finished, + })); + println!("{phase} {}", rows.last().unwrap()); + tokio::time::sleep(Duration::from_millis(1500)).await; + } + } + stop.store(true, Ordering::Relaxed); + let load_finals = match load { Some(h) => Some(h.await.unwrap()), None => None }; + let mut sound: Vec = rows.iter().filter_map(|r| r["first_sound_ms"].as_i64()).collect(); + sound.sort_unstable(); + let pick = |q: f64| sound.get(((sound.len() as f64 - 1.0) * q).round() as usize).copied(); + report.insert(phase.into(), json!({ + "rows": rows, "answered": sound.len(), "asked": rows.len(), + "first_sound_ms": {"min": sound.first(), "median": pick(0.5), "p90": pick(0.9), "max": sound.last()}, + "background_finals": load_finals, + })); + } + println!("live round trip {}", serde_json::to_string_pretty(&Value::Object(report.clone())).unwrap()); + })).await; + + let _ = speaker_songbird.remove(GuildId::new(guild)).await; + s_shards.shutdown_all().await; + services.core.leave("test").await; + services.core.close().await; + services.worker.close(); + services.worker_process.stop().await; + if let Err(panic) = steps { + std::panic::resume_unwind(panic); + } + // Every question is answered aloud. + for phase in ["alone", "with_9_more_voices"] { + let p = &report[phase]; + assert_eq!(p["answered"], p["asked"], "{phase}: not every question got a spoken answer: {p}"); + } +} + diff --git a/docs/v2/roadmap.md b/docs/v2/roadmap.md index 792fc53..bdff240 100644 --- a/docs/v2/roadmap.md +++ b/docs/v2/roadmap.md @@ -8,7 +8,7 @@ | M1 | 음성 워커 | 화자별 스트리밍 STT(공용 모델, 배치), 문장 단위 TTS를 WebSocket으로 제공. 녹음 파일 10개 동시 입력 테스트 통과. 구현과 테스트 완료(2026-11-11): `src/voice_worker/`, 스펙은 [voice_worker.spec.md](../../src/voice_worker/voice_worker.spec.md). 이 서버의 RTX 5050에서 10명이 겹쳐 말하는 실시간 입력(48kHz 스테레오, M0 한국어 샘플 8개를 10명에게 나눠 줌, 절반은 디스코드 speaking 종료, 절반은 무음으로 끝남)을 넣어 10명 모두 최종 전사를 받았고 문자 오류율은 평균 4%, 최대 19%("일곱 시"를 "7시"로 적은 것), 말 끝 판정부터 최종 전사 전송까지 중앙값 0.64초, 최대 1.56초였습니다. TTS는 첫 문장 소리가 0.2초에 나왔고, 그 소리를 다시 넣으면 같은 문장으로 받아 적혔습니다. 샘플이 MeloTTS 합성 음성이라 실제 사람 녹음과 게임PC 수치는 아직 없습니다 | | M2 | 디스코드 음성 코어 이전 | v1 봇 기능을 새 앱 안으로 이전. 입장/퇴장, 화자별 수신, 재생, 정지 명령 동작. 채팅 채널 연결(읽기·보내기). 구현과 테스트 완료(2026-11-11): `app/`(Rust, serenity + songbird), 스펙은 [discord_core.spec.md](../../app/src/discord_core.spec.md). 처음 Electron + TypeScript로 만든 것을 사용자 요청으로 Rust로 다시 씀. 앱이 음성 워커를 띄우고(실행마다 새 토큰, 죽으면 다시 시작) 연결이 끊기면 다시 붙습니다. 음성 채널에 들어갈 때마다 전사 고지를 채널 채팅에 올립니다. songbird 0.6.1의 DAVE 수신 해독이 조각 3분의 1가량을 깨뜨려서(20ms마다 음이 바뀌는 시험 신호로 확인, 보내기는 정상) 받은 패킷의 순서 맞추기와 Opus 해독은 앱이 직접 합니다. 실제 디스코드에서 봇 두 개로 확인(이 서버의 RTX 5050): 다른 봇이 채널에 튼 녹음 문장 5개를 모두 받아 적었고(문자 오류율 3개 0%, "기록해"를 "비록해"로 적은 1개 5%, "일곱 시"를 "7시"로 적은 1개 12.5%), 말이 끝난 뒤 최종 전사까지 0.71~0.90초였습니다. 자비스가 말한 문장을 상대 봇이 받아 다시 전사하니 오류율 3.4%였고, 정지 명령 뒤 0.08초 만에 소리가 끊겼습니다. 채팅 채널은 새 글 받기, 최근 글 읽기, 보내기(2,000자 넘으면 나눔, 아무도 호출하지 않음)가 됩니다. 사람이 직접 말한 소리와 게임PC(Windows) 빌드는 아직 확인하지 않았고, 음성으로 "자비스, 멈춰"는 호출 판정이 필요해 M4에서 합니다 | | M3 | 두뇌 연결 | 기존 jarvis를 Ollama 대신 Strata 주소로 연결. 대화 기록 저장소와 지난 대화 전체 검색(본인 기록 + 등록한 채팅 채널 + 같은 음성 채널의 다른 사람 말). 채팅 채널 도구(읽기·검색·보내기·수정·반응·삭제·고정). 메모리, 날씨, 웹 검색, 식단, MCP 기존 테스트와 평가(evals) 통과. 1단계 완료(2026-11-11): LLM 주소가 `/v1`로 끝나면 OpenAI 호환 방식(`/chat/completions`, `/embeddings`)으로 부름. 형식 변환은 `src/jarvis/llm.py` 한곳에서 하고 두뇌의 나머지 코드는 그대로 씀. 대화, 도구 호출, 스트리밍, 의도 판정, 받아쓰기 정리, 미리 불러오기가 모두 이 방식으로 감. 이 서버 Ollama의 `/v1` 주소와 qwen2.5:7b로 실제 두뇌 한 턴을 돌려 "서울 날씨 어때?"에 날씨 도구를 부르고 그 결과로 답하는 것을 확인함. Strata에는 임베딩 모델이 없어 지난 기록 검색은 낱말 검색으로 함. 2단계 완료(2026-11-11): 대화 기록 저장소 `src/jarvis/memory/history.py`(스펙 [history.spec.md](../../src/jarvis/memory/history.spec.md)). 음성 전사, 자비스의 답, 채팅 채널 글, 음성 채널 출입 시간을 저장하고, 묻는 사람이 볼 수 있는 기록(본인 기록, 채팅 채널, 함께 있던 동안의 다른 사람 말)만 찾음. 전체 기간에서 관련도 순으로 찾고, 기록 10만 개에서 검색 48~143ms. 두뇌는 찾은 기록을 받아 지시문에 참고 자료로 넣음(평가 `evals/test_history_context_recall.py`, qwen2.5:7b에서 3번 모두 통과). 3단계 완료(2026-11-11): 앱이 음성 워커에 음성 채널 입장·퇴장, 사람 출입, 등록한 채팅 채널의 글·수정·삭제를 알리고, 워커가 최종 전사를 저장함. 워커는 `--history`로 저장소를, `--brain`으로 두뇌를 켜고, `reply` 요청에 묻는 사람의 범위로 찾은 기록을 넣어 답하고(`reply_text`) 음성이면 바로 말함. 실제 디스코드 시험(봇 두 개)에서 전사 8개가 이름과 함께 저장되고, 채팅 수정은 반영, 삭제한 글은 빠지고, 자비스가 나간 뒤 출입 기록이 모두 닫힘. 워커와 실제 두뇌(이 서버 Ollama `/v1`, qwen2.5:7b, 맥락 8천 토큰)로 다른 사람이 채팅에 남긴 약속을 4번 물어 4번 모두 맞게 답함. Ollama의 `/v1`은 맥락을 2,048토큰으로 고정해 지시문을 자르므로, Ollama로 시험할 때는 `num_ctx`를 넣은 모델 이름을 씀(Strata는 시작할 때 맥락을 정해 해당 없음). v2 두뇌는 한 사람용인 v1 장기 기억(프로필·일기·그래프)을 넣지 않고, 답하는 동안 원문이 로그에 찍히지 않게 함. 언제 `reply`를 보낼지(호출 판정)와 음성 답 재생 연결은 M4. 4단계 완료(2026-11-11): 채팅 채널 도구 `chatChannels`(목록·읽기·검색·보내기·수정·반응·삭제·고정, 스펙 [chat_channels.spec.md](../../src/jarvis/tools/builtin/chat_channels.spec.md)). 읽기·검색은 대화 기록 저장소에서, 나머지는 앱이 채널별 허용 설정을 확인하고 디스코드에서 실행. 삭제는 다음 메시지에서 사용자가 동의해야 실행하고, 채널 글은 명령이 아닌 자료로 표시. 실제 디스코드에서 수정(자기 글만)·반응·삭제·고정을 확인(음성 채널의 채팅은 디스코드가 고정을 막아 오류로 돌아옴). 평가(qwen2.5:7b) 3번에 12번 중 10번 통과, 글 속 명령을 따르지 않기와 같은 턴에 지우지 않기는 12번 모두 지킴. 식단 기록은 사람별로 나눔(v1 데이터는 그대로). 기존 테스트·평가 확인(2026-11-11): 단위 테스트는 2,215개 통과, 10개 실패이고, 실패 10개는 이 서버에 PortAudio가 없어 마이크 코드(음성 듣기·받아쓰기)가 꺼진 탓임. 갱신되지 않았던 테스트 4개(한국어 한 문장 날씨 3, 잡담 빠른 경로를 지나는 캐시 1)와 설치된 PyQt6를 가짜로 바꿔 다른 화면 테스트를 깨뜨리던 테스트 1곳을 고침. 평가(evals, qwen2.5:7b)는 145개 통과, 56개 실패, 60개 건너뜀. 실패 중 54개는 M3 이전 커밋(beaacb3)에서도 실패하거나, 3번씩 다시 돌린 통과 횟수가 양쪽이 같아 M3 때문에 생긴 실패는 없음. 나머지 2개는 새 채팅 도구 평가의 알려진 실패(12번 중 2번). 원래 실패하는 평가는 이 서버에 없는 모델(gpt-oss:20b, nomic-embed-text)을 쓰거나 qwen2.5:7b가 웹 검색·날씨 도구를 부르지 않는 경우가 대부분임. 실제로 쓸 모델로 평가 확인(2026-11-11): 게임PC의 Strata(Qwen3.6-35B-A3B UD-Q4_K_XL, 맥락 32K, 평소 배치)에 SSH 터널로 붙어 이 서버에서 평가 전체를 돌림. 193개 통과, 12개 실패, 60개 건너뜀(의도 판정·도구 선택 평가는 gemma4 단계에서만 돌고, gemma4는 이 서버 Ollama에 없음), 8분 13초. 실패 12개를 3번씩 다시 돌리니 5개는 3번 모두 실패(알려진 위치를 날씨 도구 인자로 넣지 않음 2, 파리·런던 비교에서 날씨 도구를 한 번만 부름 1, 지식 그래프 갈래 분류 1, 맥락에 있는 위치를 기억 검색 질문에 다시 넣음 1)했고, 날씨 한 번 부르기 평가는 엔진의 정해진 날씨 경로(`_maybe_deterministic_weather`)가 평가가 바꿔 둔 도구 실행기를 거치지 않고 실제 날씨를 받아 한국어로 바로 답해 3번 모두 실패함(모델과 상관없음). 나머지 6개는 3번 중 1~3번 통과함. qwen2.5:7b에서 없던 실패는 기억 검색 질문 1개(3번 모두)와 날씨 다시 시도 2개(다시 돌리면 6번 중 4번 통과)임 실패 고침(2026-11-11): 엔진의 정해진 한국어 날씨 경로를 뺌(평가의 도구 실행기를 거치지 않았고, 사용자가 말한 위치를 쓰지 못함, 큰 모델은 도구 결과를 한국어 한 문장으로 그대로 답함). 날씨 도구와 대화 지시문은 사용자가 대화나 기억에서 말한 위치를 넣고, 자동으로 잡힌 위치는 옮겨 적지 않게 함. "구, 시, 나라" 이름이 안 찾아지면 넓은 지역으로 다시 찾음. 계획 단계에 현재 시간·위치 줄을 주어, 위치를 모를 때만 기억에서 사용자 위치를 먼저 찾게 함. 같은 도구 반복 제한이 이전 답변의 호출까지 세어 사용자가 다시 해 달라고 해도 막던 버그를 고침. 기억 검색어 지시문에서 평가와 같은 문장의 예시를 바꾸고 현재 맥락 블록을 예시 뒤로 옮김(위치를 모를 때는 여전히 묻는지 보는 평가 추가, qwen2.5:7b는 바꾸기 전에도 묻지 않음). 평가 전체 202개 통과, 4개 실패, 9분 3초. 이 전체 실행의 날씨 실패 1개는 장소를 말하지 않은 "what's the weather this week"에 자동으로 잡힌 위치(`Hackney, England, UK`)를 인자로 옮겨 적은 것으로, 그 뒤 날씨 도구와 지시문을 사용자가 말한 위치만 넣도록 좁혀 고침. 고친 뒤 날씨 평가 12개를 따로 3번 돌려 36번 중 34번 통과(이 평가는 3번 모두 통과, 실패 2번은 날씨 한 번 부르기 평가가 파리 날씨 답에 도시 이름을 다시 말하지 않은 것). 전체 실행의 나머지 실패는 지식 그래프 갈래 분류 1개(모델이 "사용자가 물었다"를 사용자 사실로 하나 더 남김, 지시문을 두 번 고쳐도 같아 되돌림, v2는 v1 장기 기억을 쓰지 않음)와 다시 돌리면 통과하는 2개(유명인 두 턴 대화, 최근 일기 반영) | -| M4 | 왕복 완성과 지연 튜닝 | 호출어·호출 방식·지정한 사람 설정, 동시 대화 응답 정책 4가지(기본 "처음 대화만")와 정책별 끼어들기 규칙. 말 끝부터 첫 소리까지 실측 1.5초 이내, 10명 채널 부하 테스트. 1단계 완료(2026-11-11): 앱의 호출 판정 `app/src/calls.rs`와 응답 정책 `app/src/policy.rs`(스펙 [conversation.spec.md](../../app/src/conversation.spec.md)), 설정 `call`·`response`. 비슷한 발음은 유니코드 NFKD로 한글을 자모로 나눠 편집 거리로 판단(기본 0.2: "자비즈"는 호출, "서비스"는 아님). 정책은 말이 끝난 시각 순서, 먼저 끝난 말의 전사 대기(최대 0.8초), 끼어들기, 놓친 요청 사유를 가짜 시각으로 시험함. 2단계 완료(2026-11-11): 대화 루프 `app/src/conversation.rs`가 최종 전사를 호출 판정과 응답 정책에 넣고, 정책의 결정대로 두뇌에 답을 요청해(`reply`, 답은 워커가 같은 id로 읽음) 앱의 재생 대기열에서 재생, 끼어들 때는 그 답만 멈춤, "자비스 멈춰"는 모든 말을 멈춤, 놓친 요청은 글 없이 최근 100개를 남김. 두뇌의 두 판정 `src/voice_worker/judges.py`(봇에게 하는 말인지, 중요도 순위)는 답과 따로 돌아 기다리지 않음. 평가 `evals/test_voice_judges.py` 12개를 qwen2.5:7b에서 모두 통과. 답을 만드는 중에 멈춘 요청은 말하지 않음. 실제 Python 워커(가짜 두뇌)와 앱의 통합 시험 통과. 3단계 완료(2026-11-11): 채팅 채널 호출. 채널마다 `answer`(호출어로 부를 때만 / 모든 메시지에 대답), 채팅 호출어(`call.chatWakeWords`, 없으면 음성과 같음)와 지정한 사람 설정은 음성과 같이 씀. 답은 같은 채널에 원래 메시지의 답글로 올리고 아무도 부르지 않음. 다른 봇의 글과 보내기가 꺼진 채널에는 답하지 않음. 음성 대화 순서와는 따로 감(워커가 음성 답과 채팅 답을 따로 써서 다른 사람의 채팅 답 때문에 음성 답이 기다리지 않음. 한 사람의 답은 물은 순서대로 하나씩 씀. 두 답의 LLM 호출이 동시에 돌려면 Strata를 `--parallel 2`로 띄움, 앱이 Strata를 띄우는 M5 전까지). 5분 넘게 늦은 채팅 답은 올리지 않음. 실제 디스코드 시험과 지연 측정은 4단계 | +| M4 | 왕복 완성과 지연 튜닝 | 호출어·호출 방식·지정한 사람 설정, 동시 대화 응답 정책 4가지(기본 "처음 대화만")와 정책별 끼어들기 규칙. 말 끝부터 첫 소리까지 실측 1.5초 이내, 10명 채널 부하 테스트. 1단계 완료(2026-11-11): 앱의 호출 판정 `app/src/calls.rs`와 응답 정책 `app/src/policy.rs`(스펙 [conversation.spec.md](../../app/src/conversation.spec.md)), 설정 `call`·`response`. 비슷한 발음은 유니코드 NFKD로 한글을 자모로 나눠 편집 거리로 판단(기본 0.2: "자비즈"는 호출, "서비스"는 아님). 정책은 말이 끝난 시각 순서, 먼저 끝난 말의 전사 대기(최대 0.8초), 끼어들기, 놓친 요청 사유를 가짜 시각으로 시험함. 2단계 완료(2026-11-11): 대화 루프 `app/src/conversation.rs`가 최종 전사를 호출 판정과 응답 정책에 넣고, 정책의 결정대로 두뇌에 답을 요청해(`reply`, 답은 워커가 같은 id로 읽음) 앱의 재생 대기열에서 재생, 끼어들 때는 그 답만 멈춤, "자비스 멈춰"는 모든 말을 멈춤, 놓친 요청은 글 없이 최근 100개를 남김. 두뇌의 두 판정 `src/voice_worker/judges.py`(봇에게 하는 말인지, 중요도 순위)는 답과 따로 돌아 기다리지 않음. 평가 `evals/test_voice_judges.py` 12개를 qwen2.5:7b에서 모두 통과. 답을 만드는 중에 멈춘 요청은 말하지 않음. 실제 Python 워커(가짜 두뇌)와 앱의 통합 시험 통과. 3단계 완료(2026-11-11): 채팅 채널 호출. 채널마다 `answer`(호출어로 부를 때만 / 모든 메시지에 대답), 채팅 호출어(`call.chatWakeWords`, 없으면 음성과 같음)와 지정한 사람 설정은 음성과 같이 씀. 답은 같은 채널에 원래 메시지의 답글로 올리고 아무도 부르지 않음. 다른 봇의 글과 보내기가 꺼진 채널에는 답하지 않음. 음성 대화 순서와는 따로 감(워커가 음성 답과 채팅 답을 따로 써서 다른 사람의 채팅 답 때문에 음성 답이 기다리지 않음. 한 사람의 답은 물은 순서대로 하나씩 씀. 두 답의 LLM 호출이 동시에 돌려면 Strata를 `--parallel 2`로 띄움, 앱이 Strata를 띄우는 M5 전까지). 5분 넘게 늦은 채팅 답은 올리지 않음. 실제 디스코드 시험과 지연 측정은 4단계. 4단계 첫 측정(2026-11-12): 앱의 실제 서비스(`start_services`: 대화 루프, 응답 정책, 워커, 두뇌)를 게임PC Strata(`--parallel 2`)에 붙이고, 봇 두 개로 질문 5개를 2번씩 말해 잼(`app/tests/live_round_trip.rs`). 10개 모두 소리로 답했고, 말 끝부터 첫 소리까지 중앙값 3.5초(최소 2.8초, 날씨 도구 8.6초). 9명이 동시에 말하는 부하(워커의 두 번째 연결로 녹음 문장 9개를 실시간으로 넣음, 그동안 최종 전사 259개)에서는 중앙값 4.4초, 최종 전사가 0.6~0.9초에서 0.8~1.8초로 늦어졌고 1번은 "기분"을 "딥"으로 잘못 들어 날씨 도구를 불러 18.8초가 걸림. 짧은 답의 시간은 최종 전사 0.65~0.85초, 두뇌 2.0~2.9초(도구 고르기 0.42초, 계획 0.5초, 답 호출의 지시문 약 4,300토큰 읽기 1.1초와 생성), 재생 시작과 전달 약 0.4초. Strata의 Qwen3.6 엔진은 지시문 앞부분 재사용을 하지 않아(`--prompt-cache-every`는 "이 엔진의 옵션이 아님"으로 무시됨, 같은 대화를 그대로 이어 갈 때만 재사용) 매 호출을 처음부터 읽음. 생성은 0.2~0.5초라 문장 단위로 흘려도 짧은 답은 거의 빨라지지 않음. 1.5초 기준은 아직 못 맞춤. 같은 시험에서 찾아 고친 것: v1 TTS 설정(영어 전용 Piper) 때문에 한국어 질문에 영어로 답하던 것(v2 두뇌는 묻는 사람의 언어로 답함), 호출어 뒤에 쉬면 "자비스"만 따로 끊겨 그 이름에만 답하고 이어진 질문은 무시하던 것(이제 같은 사람이 이어서 하는 말과 합침, `call.followUpMs`) | | M5 | 관리 앱 기본 | 첫 실행 마법사, 데이터 폴더, 런타임·모델 자동 설치, 대시보드, 봇/채널·호출/채팅 채널(디스코드 채널 이름·주제 반영 포함)/대화 기억/모델 설정, 로그 화면(보기·복사·다운로드) | | M6 | 기능 화면과 브라우저 | 기능 켜기/끄기, MCP 관리, 봇용 크롬(가상 모니터에 둠, Virtual Display Driver 포함), 예약 수집 틀(대상은 비움). 디스코드 "화면" 탭 공유, 커서, 모니터 해제 때 창 위치 확인 | | M7 | PC 제어와 화면 보기 | 아래 목록에 있습니다. |