use super::Core;
use crate::durable_store::lock as lock_session;
use jsrt::sync;
use resources::keep_going::{self, Limits, Next, RunEnd, STATE_KEY, SessionPersona, Toggle};
use serde_json::{Value, json};
use session_journal::Write;
use session_journal::ns::MODULE;
impl Core {
pub(super) fn persona_load(&mut self) {
let saved = lock_session(&self.session).value(MODULE, STATE_KEY).cloned();
self.persona_session = SessionPersona::from_json(saved.as_ref());
self.runtime.system.set_persona(self.persona_session.prompt_override());
}
fn persona_save(&mut self) {
self.runtime.system.set_persona(self.persona_session.prompt_override());
let value = self.persona_session.to_json();
let _ = match &self.runtime.services.values {
Some(values) => values.set(MODULE, STATE_KEY, &value),
None => lock_session(&self.session)
.commit(&[Write::set(MODULE, STATE_KEY, value)])
.map(drop),
};
}
fn persona_limits(&self) -> Limits {
Limits::from_env(&*self.env.var)
}
pub(super) fn persona_user_input(&mut self, text: &str) -> Option<String> {
self.persona.user_input();
let before = self.persona_session.clone();
let notice = self.persona_session.user_input(text, jsrt::date::now_ms());
if self.persona_session != before {
self.persona_save();
}
notice
}
pub(super) fn persona_command(&mut self, command: &str, args: &str) -> Result<Value, String> {
let global = self.persona_on();
let limits = self.persona_limits();
let before = self.persona_session.clone();
let text = self
.persona_session
.command(command, args, jsrt::date::now_ms(), global, limits)?;
if self.persona_session != before {
self.persona_save();
}
let state = self.persona_session.to_json();
Ok(json!({
"text": text,
"persona": state["persona"],
"effective": self.persona_session.effective(global),
"keepGoing": state["keepGoing"],
}))
}
pub(super) fn persona_assistant(&mut self, message: &Value) {
if self.run.is_none() {
return;
}
self.persona.assistant_message(message);
let calls = message["content"]
.as_array()
.is_some_and(|blocks| blocks.iter().any(|b| b["type"] == "toolCall"));
if calls && self.persona_session.worked() {
self.persona_save();
}
}
fn persona_effective(&self) -> bool {
match self.persona_session.toggle {
Toggle::On => true,
Toggle::Off => false,
Toggle::Auto => self.persona_on(),
}
}
fn persona_on(&self) -> bool {
let config = &self.runtime.config;
let settings =
config::settings::SettingsManager::create(&self.env.cwd, &config.agent_dir, config.project_trusted);
resources::persona::enabled(settings.settings())
}
pub(super) fn persona_run_ended(&mut self, aborted: bool, failed: bool) {
let pending =
!sync::lock(&self.queues).items.is_empty() || !self.deferred.is_empty() || !self.after_run.is_empty();
let limits = self.persona_limits();
let before = self.persona_session.clone();
let next = keep_going::after_run(
&mut self.persona_session,
&RunEnd {
aborted,
failed,
pending_input: pending,
tool_calls: self.persona.tool_calls,
text: &self.persona.text,
},
jsrt::date::now_ms(),
limits,
);
if self.persona_session != before {
self.persona_save();
}
match next {
Next::Persona => {}
Next::Stop => {
self.persona.run_ended(false, aborted, failed, pending);
return;
}
Next::Continue { .. } | Next::Final { .. } => {
if matches!(next, Next::Final { .. }) {
self.persona.nudges = resources::persona::MAX_NUDGES;
}
if let Some(message) = keep_going::nudge_message(&next, limits, jsrt::date::now_ms()) {
let _ = self.prompt_with(message, None, true);
}
return;
}
}
let candidate = !aborted
&& !failed
&& !pending
&& resources::persona::should_nudge(&self.persona.text, self.persona.tool_calls);
let persona = candidate && self.persona_effective();
let Some(n) = self.persona.run_ended(persona, aborted, failed, pending) else {
return;
};
let message = resources::persona::nudge_message(n, jsrt::date::now_ms());
let _ = self.prompt_with(message, None, true);
}
pub(super) fn persona_shown(&self, message: Value) -> Value {
match self.run.as_ref() {
Some(run)
if run.prompt_pending
&& message["role"] == "user"
&& (run.prompt["customType"] == protocol::custom_types::NUDGE
|| run.prompt["customType"] == protocol::custom_types::SCHEDULE) =>
{
run.prompt.clone()
}
_ => message,
}
}
pub(super) fn persona_run_started(&mut self) {
self.persona.run_started();
}
}