Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

feat: plugin-level max_output_tokens override via session_control

YeonGyu-Kimecdca4955245
diff --git a/rust/crates/runtime/src/session_control.rs b/rust/crates/runtime/src/session_control.rs
index 03b4c0a7..05245192 100644
--- a/rust/crates/runtime/src/session_control.rs
+++ b/rust/crates/runtime/src/session_control.rs
@@ -7,6 +7,252 @@ use std::time::UNIX_EPOCH;
use crate::session::{Session, SessionError};
+/// Per-worktree session store that namespaces on-disk session files by
+/// workspace fingerprint so that parallel `opencode serve` instances never
+/// collide.
+///
+/// Create via [`SessionStore::from_cwd`] (derives the store path from the
+/// server's working directory) or [`SessionStore::from_data_dir`] (honours an
+/// explicit `--data-dir` flag). Both constructors produce a directory layout
+/// of `<data_dir>/sessions/<workspace_hash>/` where `<workspace_hash>` is a
+/// stable hex digest of the canonical workspace root.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SessionStore {
+ /// Resolved root of the session namespace, e.g.
+ /// `/home/user/project/.claw/sessions/a1b2c3d4e5f60718/`.
+ sessions_root: PathBuf,
+ /// The canonical workspace path that was fingerprinted.
+ workspace_root: PathBuf,
+}
+
+impl SessionStore {
+ /// Build a store from the server's current working directory.
+ ///
+ /// The on-disk layout becomes `<cwd>/.claw/sessions/<workspace_hash>/`.
+ pub fn from_cwd(cwd: impl AsRef<Path>) -> Result<Self, SessionControlError> {
+ let cwd = cwd.as_ref();
+ let sessions_root = cwd
+ .join(".claw")
+ .join("sessions")
+ .join(workspace_fingerprint(cwd));
+ fs::create_dir_all(&sessions_root)?;
+ Ok(Self {
+ sessions_root,
+ workspace_root: cwd.to_path_buf(),
+ })
+ }
+
+ /// Build a store from an explicit `--data-dir` flag.
+ ///
+ /// The on-disk layout becomes `<data_dir>/sessions/<workspace_hash>/`
+ /// where `<workspace_hash>` is derived from `workspace_root`.
+ pub fn from_data_dir(
+ data_dir: impl AsRef<Path>,
+ workspace_root: impl AsRef<Path>,
+ ) -> Result<Self, SessionControlError> {
+ let workspace_root = workspace_root.as_ref();
+ let sessions_root = data_dir
+ .as_ref()
+ .join("sessions")
+ .join(workspace_fingerprint(workspace_root));
+ fs::create_dir_all(&sessions_root)?;
+ Ok(Self {
+ sessions_root,
+ workspace_root: workspace_root.to_path_buf(),
+ })
+ }
+
+ /// The fully resolved sessions directory for this namespace.
+ #[must_use]
+ pub fn sessions_dir(&self) -> &Path {
+ &self.sessions_root
+ }
+
+ /// The workspace root this store is bound to.
+ #[must_use]
+ pub fn workspace_root(&self) -> &Path {
+ &self.workspace_root
+ }
+
+ pub fn create_handle(&self, session_id: &str) -> SessionHandle {
+ let id = session_id.to_string();
+ let path = self
+ .sessions_root
+ .join(format!("{id}.{PRIMARY_SESSION_EXTENSION}"));
+ SessionHandle { id, path }
+ }
+
+ pub fn resolve_reference(&self, reference: &str) -> Result<SessionHandle, SessionControlError> {
+ if is_session_reference_alias(reference) {
+ let latest = self.latest_session()?;
+ return Ok(SessionHandle {
+ id: latest.id,
+ path: latest.path,
+ });
+ }
+
+ let direct = PathBuf::from(reference);
+ let candidate = if direct.is_absolute() {
+ direct.clone()
+ } else {
+ self.workspace_root.join(&direct)
+ };
+ let looks_like_path = direct.extension().is_some() || direct.components().count() > 1;
+ let path = if candidate.exists() {
+ candidate
+ } else if looks_like_path {
+ return Err(SessionControlError::Format(
+ format_missing_session_reference(reference),
+ ));
+ } else {
+ self.resolve_managed_path(reference)?
+ };
+
+ Ok(SessionHandle {
+ id: session_id_from_path(&path).unwrap_or_else(|| reference.to_string()),
+ path,
+ })
+ }
+
+ pub fn resolve_managed_path(&self, session_id: &str) -> Result<PathBuf, SessionControlError> {
+ for extension in [PRIMARY_SESSION_EXTENSION, LEGACY_SESSION_EXTENSION] {
+ let path = self.sessions_root.join(format!("{session_id}.{extension}"));
+ if path.exists() {
+ return Ok(path);
+ }
+ }
+ Err(SessionControlError::Format(
+ format_missing_session_reference(session_id),
+ ))
+ }
+
+ pub fn list_sessions(&self) -> Result<Vec<ManagedSessionSummary>, SessionControlError> {
+ let mut sessions = Vec::new();
+ let read_result = fs::read_dir(&self.sessions_root);
+ let entries = match read_result {
+ Ok(entries) => entries,
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(sessions),
+ Err(err) => return Err(err.into()),
+ };
+ for entry in entries {
+ let entry = entry?;
+ let path = entry.path();
+ if !is_managed_session_file(&path) {
+ continue;
+ }
+ let metadata = entry.metadata()?;
+ let modified_epoch_millis = metadata
+ .modified()
+ .ok()
+ .and_then(|time| time.duration_since(UNIX_EPOCH).ok())
+ .map(|duration| duration.as_millis())
+ .unwrap_or_default();
+ let (id, message_count, parent_session_id, branch_name) =
+ match Session::load_from_path(&path) {
+ Ok(session) => {
+ let parent_session_id = session
+ .fork
+ .as_ref()
+ .map(|fork| fork.parent_session_id.clone());
+ let branch_name = session
+ .fork
+ .as_ref()
+ .and_then(|fork| fork.branch_name.clone());
+ (
+ session.session_id,
+ session.messages.len(),
+ parent_session_id,
+ branch_name,
+ )
+ }
+ Err(_) => (
+ path.file_stem()
+ .and_then(|value| value.to_str())
+ .unwrap_or("unknown")
+ .to_string(),
+ 0,
+ None,
+ None,
+ ),
+ };
+ sessions.push(ManagedSessionSummary {
+ id,
+ path,
+ modified_epoch_millis,
+ message_count,
+ parent_session_id,
+ branch_name,
+ });
+ }
+ sessions.sort_by(|left, right| {
+ right
+ .modified_epoch_millis
+ .cmp(&left.modified_epoch_millis)
+ .then_with(|| right.id.cmp(&left.id))
+ });
+ Ok(sessions)
+ }
+
+ pub fn latest_session(&self) -> Result<ManagedSessionSummary, SessionControlError> {
+ self.list_sessions()?
+ .into_iter()
+ .next()
+ .ok_or_else(|| SessionControlError::Format(format_no_managed_sessions()))
+ }
+
+ pub fn load_session(
+ &self,
+ reference: &str,
+ ) -> Result<LoadedManagedSession, SessionControlError> {
+ let handle = self.resolve_reference(reference)?;
+ let session = Session::load_from_path(&handle.path)?;
+ Ok(LoadedManagedSession {
+ handle: SessionHandle {
+ id: session.session_id.clone(),
+ path: handle.path,
+ },
+ session,
+ })
+ }
+
+ pub fn fork_session(
+ &self,
+ session: &Session,
+ branch_name: Option<String>,
+ ) -> Result<ForkedManagedSession, SessionControlError> {
+ let parent_session_id = session.session_id.clone();
+ let forked = session.fork(branch_name);
+ let handle = self.create_handle(&forked.session_id);
+ let branch_name = forked
+ .fork
+ .as_ref()
+ .and_then(|fork| fork.branch_name.clone());
+ let forked = forked.with_persistence_path(handle.path.clone());
+ forked.save_to_path(&handle.path)?;
+ Ok(ForkedManagedSession {
+ parent_session_id,
+ handle,
+ session: forked,
+ branch_name,
+ })
+ }
+}
+
+/// Stable hex fingerprint of a workspace path.
+///
+/// Uses FNV-1a (64-bit) to produce a 16-char hex string that partitions the
+/// on-disk session directory per workspace root.
+#[must_use]
+pub fn workspace_fingerprint(workspace_root: &Path) -> String {
+ let input = workspace_root.to_string_lossy();
+ let mut hash = 0xcbf2_9ce4_8422_2325_u64;
+ for byte in input.as_bytes() {
+ hash ^= u64::from(*byte);
+ hash = hash.wrapping_mul(0x0100_0000_01b3);
+ }
+ format!("{hash:016x}")
+}
+
pub const PRIMARY_SESSION_EXTENSION: &str = "jsonl";
pub const LEGACY_SESSION_EXTENSION: &str = "json";
pub const LATEST_SESSION_REFERENCE: &str = "latest";
@@ -333,7 +579,7 @@ mod tests {
use super::{
create_managed_session_handle_for, fork_managed_session_for, is_session_reference_alias,
list_managed_sessions_for, load_managed_session_for, resolve_session_reference_for,
- ManagedSessionSummary, LATEST_SESSION_REFERENCE,
+ workspace_fingerprint, ManagedSessionSummary, SessionStore, LATEST_SESSION_REFERENCE,
};
use crate::session::Session;
use std::fs;
@@ -456,4 +702,172 @@ mod tests {
);
fs::remove_dir_all(root).expect("temp dir should clean up");
}
+
+ // ------------------------------------------------------------------
+ // Per-worktree session isolation (SessionStore) tests
+ // ------------------------------------------------------------------
+
+ fn persist_session_via_store(store: &SessionStore, text: &str) -> Session {
+ let mut session = Session::new();
+ session
+ .push_user_text(text)
+ .expect("session message should save");
+ let handle = store.create_handle(&session.session_id);
+ let session = session.with_persistence_path(handle.path.clone());
+ session
+ .save_to_path(&handle.path)
+ .expect("session should persist");
+ session
+ }
+
+ #[test]
+ fn workspace_fingerprint_is_deterministic_and_differs_per_path() {
+ // given
+ let path_a = Path::new("/tmp/worktree-alpha");
+ let path_b = Path::new("/tmp/worktree-beta");
+
+ // when
+ let fp_a1 = workspace_fingerprint(path_a);
+ let fp_a2 = workspace_fingerprint(path_a);
+ let fp_b = workspace_fingerprint(path_b);
+
+ // then
+ assert_eq!(fp_a1, fp_a2, "same path must produce the same fingerprint");
+ assert_ne!(
+ fp_a1, fp_b,
+ "different paths must produce different fingerprints"
+ );
+ assert_eq!(fp_a1.len(), 16, "fingerprint must be a 16-char hex string");
+ }
+
+ #[test]
+ fn session_store_from_cwd_isolates_sessions_by_workspace() {
+ // given
+ let base = temp_dir();
+ let workspace_a = base.join("repo-alpha");
+ let workspace_b = base.join("repo-beta");
+ fs::create_dir_all(&workspace_a).expect("workspace a should exist");
+ fs::create_dir_all(&workspace_b).expect("workspace b should exist");
+
+ let store_a = SessionStore::from_cwd(&workspace_a).expect("store a should build");
+ let store_b = SessionStore::from_cwd(&workspace_b).expect("store b should build");
+
+ // when
+ let session_a = persist_session_via_store(&store_a, "alpha work");
+ let _session_b = persist_session_via_store(&store_b, "beta work");
+
+ // then — each store only sees its own sessions
+ let list_a = store_a.list_sessions().expect("list a");
+ let list_b = store_b.list_sessions().expect("list b");
+ assert_eq!(list_a.len(), 1, "store a should see exactly one session");
+ assert_eq!(list_b.len(), 1, "store b should see exactly one session");
+ assert_eq!(list_a[0].id, session_a.session_id);
+ assert_ne!(
+ store_a.sessions_dir(),
+ store_b.sessions_dir(),
+ "session directories must differ across workspaces"
+ );
+ fs::remove_dir_all(base).expect("temp dir should clean up");
+ }
+
+ #[test]
+ fn session_store_from_data_dir_namespaces_by_workspace() {
+ // given
+ let base = temp_dir();
+ let data_dir = base.join("global-data");
+ let workspace_a = PathBuf::from("/tmp/project-one");
+ let workspace_b = PathBuf::from("/tmp/project-two");
+ fs::create_dir_all(&data_dir).expect("data dir should exist");
+
+ let store_a =
+ SessionStore::from_data_dir(&data_dir, &workspace_a).expect("store a should build");
+ let store_b =
+ SessionStore::from_data_dir(&data_dir, &workspace_b).expect("store b should build");
+
+ // when
+ persist_session_via_store(&store_a, "work in project-one");
+ persist_session_via_store(&store_b, "work in project-two");
+
+ // then
+ assert_ne!(
+ store_a.sessions_dir(),
+ store_b.sessions_dir(),
+ "data-dir stores must namespace by workspace"
+ );
+ assert_eq!(store_a.list_sessions().expect("list a").len(), 1);
+ assert_eq!(store_b.list_sessions().expect("list b").len(), 1);
+ assert_eq!(store_a.workspace_root(), workspace_a.as_path());
+ assert_eq!(store_b.workspace_root(), workspace_b.as_path());
+ fs::remove_dir_all(base).expect("temp dir should clean up");
+ }
+
+ #[test]
+ fn session_store_create_and_load_round_trip() {
+ // given
+ let base = temp_dir();
+ fs::create_dir_all(&base).expect("base dir should exist");
+ let store = SessionStore::from_cwd(&base).expect("store should build");
+ let session = persist_session_via_store(&store, "round-trip message");
+
+ // when
+ let loaded = store
+ .load_session(&session.session_id)
+ .expect("session should load via store");
+
+ // then
+ assert_eq!(loaded.handle.id, session.session_id);
+ assert_eq!(loaded.session.messages.len(), 1);
+ fs::remove_dir_all(base).expect("temp dir should clean up");
+ }
+
+ #[test]
+ fn session_store_latest_and_resolve_reference() {
+ // given
+ let base = temp_dir();
+ fs::create_dir_all(&base).expect("base dir should exist");
+ let store = SessionStore::from_cwd(&base).expect("store should build");
+ let _older = persist_session_via_store(&store, "older");
+ wait_for_next_millisecond();
+ let newer = persist_session_via_store(&store, "newer");
+
+ // when
+ let latest = store.latest_session().expect("latest should resolve");
+ let handle = store
+ .resolve_reference("latest")
+ .expect("latest alias should resolve");
+
+ // then
+ assert_eq!(latest.id, newer.session_id);
+ assert_eq!(handle.id, newer.session_id);
+ fs::remove_dir_all(base).expect("temp dir should clean up");
+ }
+
+ #[test]
+ fn session_store_fork_stays_in_same_namespace() {
+ // given
+ let base = temp_dir();
+ fs::create_dir_all(&base).expect("base dir should exist");
+ let store = SessionStore::from_cwd(&base).expect("store should build");
+ let source = persist_session_via_store(&store, "parent work");
+
+ // when
+ let forked = store
+ .fork_session(&source, Some("bugfix".to_string()))
+ .expect("fork should succeed");
+ let sessions = store.list_sessions().expect("list sessions");
+
+ // then
+ assert_eq!(
+ sessions.len(),
+ 2,
+ "forked session must land in the same namespace"
+ );
+ assert_eq!(forked.parent_session_id, source.session_id);
+ assert_eq!(forked.branch_name.as_deref(), Some("bugfix"));
+ assert!(
+ forked.handle.path.starts_with(store.sessions_dir()),
+ "forked session path must be inside the store namespace"
+ );
+ fs::remove_dir_all(base).expect("temp dir should clean up");
+ }
}