Auto-suffix session names on collision instead of failing (#10)

When a session name already exists, create appends a 6-char base36
suffix (e.g. my-plan-k3a9f2) instead of bailing. create_with_registry
now returns the actual session name so chain and create_or_join
propagate it correctly.

Author: justinmoon

src/command_surface.rs

@@ -74,11 +74,11 @@ pub fn run(args: &CommandRunArgs, registry: &WorkflowRegistry) -> Result<i32> {
                 return Ok(0);
             }
             crate::workflow::RunCommandResolution::Session {
-                session_name,
+                session_name: _,
                 agent_name,
                 create_args,
             } => {
-                create_or_join(&create_args, registry)?;
+                let session_name = create_or_join(&create_args, registry)?;
                 ensure_agent_registered(&session_name, &agent_name, registry)?;
                 let code = watch::next_with_registry(
                     &session_name,
@@ -976,14 +976,14 @@ fn resolve_run_context(
 fn create_or_join(
     create_args: &crate::cli::CreateArgs,
     registry: &WorkflowRegistry,
-) -> Result<()> {
+) -> Result<String> {
     match commands::create_with_registry(create_args, registry) {
-        Ok(()) => Ok(()),
+        Ok(name) => Ok(name),
         Err(err) => {
             // NOTE: matches the bail! message in state.rs create_session_state()
             // ("session '{}' already exists"). If that message changes, update here.
             if err.to_string().contains("already exists") {
-                Ok(())
+                Ok(create_args.name.clone())
             } else {
                 Err(err)
             }

src/commands.rs

@@ -14,6 +14,7 @@ use crate::{
     state::{
         AgentState, Config, SessionHandle, SessionPhase, SessionState, SessionType,
         create_session_state, ensure_dirs_for_session, list_sessions, now, session_dir,
+        unique_session_name,
     },
     watch,
     workflow::{
@@ -22,7 +23,7 @@ use crate::{
     },
 };
 
-pub fn create_with_registry(args: &CreateArgs, registry: &WorkflowRegistry) -> Result<()> {
+pub fn create_with_registry(args: &CreateArgs, registry: &WorkflowRegistry) -> Result<String> {
     let session_type = match args.session_type {
         SessionTypeArg::Plan => SessionType::Plan,
         SessionTypeArg::Implement => SessionType::Implement,
@@ -142,9 +143,10 @@ pub fn create_with_registry(args: &CreateArgs, registry: &WorkflowRegistry) -> R
         workflow_state,
     };
 
-    let created = create_session_state(&args.name, state)?;
+    let session_name = unique_session_name(&args.name);
+    let created = create_session_state(&session_name, state)?;
     let setup = (|| -> Result<SessionState> {
-        let handle = SessionHandle::open(&args.name)?;
+        let handle = SessionHandle::open(&session_name)?;
         let mut current = handle.load_state()?;
         dispatch_create_and_init_hooks(&mut current, &handle.session_dir, registry)?;
         handle.save_state(&current)?;
@@ -155,18 +157,18 @@ pub fn create_with_registry(args: &CreateArgs, registry: &WorkflowRegistry) -> R
         Ok(current) => current,
         Err(setup_err) => {
             rollback_failed_create(&created)
-                .with_context(|| format!("rolling back failed create for '{}'", args.name))?;
+                .with_context(|| format!("rolling back failed create for '{}'", session_name))?;
             return Err(setup_err);
         }
     };
 
     println!(
         "created {:?} session '{}' at {}",
         current.session_type,
-        args.name,
+        session_name,
         created.state_path.display()
     );
-    Ok(())
+    Ok(session_name)
 }
 
 pub fn join_with_registry(args: &JoinArgs, registry: &WorkflowRegistry) -> Result<()> {
@@ -454,10 +456,10 @@ pub fn chain_with_registry(args: &ChainArgs, registry: &WorkflowRegistry) -> Res
         review_timeout_secs: 1200,
     };
 
-    create_with_registry(&create_args, registry)?;
+    let session_name = create_with_registry(&create_args, registry)?;
     println!(
         "chained plan '{}' into implement session '{}'",
-        args.plan, args.implement
+        args.plan, session_name
     );
     Ok(())
 }

src/state.rs

@@ -2,6 +2,7 @@ use std::{
     fs::{self, File, OpenOptions},
     io::{Read, Write},
     path::{Path, PathBuf},
+    time::{SystemTime, UNIX_EPOCH},
 };
 
 use anyhow::{Context, Result, anyhow, bail};
@@ -56,6 +57,33 @@ mod tests {
         assert!(parsed.workflow_state.is_none());
     }
 
+    #[test]
+    fn session_suffix_produces_6_char_alphanumeric_string() {
+        let s = super::session_suffix();
+        assert_eq!(s.len(), 6);
+        assert!(s.chars().all(|c| c.is_ascii_alphanumeric()));
+    }
+
+    #[test]
+    fn unique_session_name_returns_base_when_no_collision() {
+        let name = format!("no-collision-test-{}", std::process::id());
+        assert_eq!(unique_session_name(&name), name);
+    }
+
+    #[test]
+    fn unique_session_name_appends_suffix_on_collision() {
+        let name = format!("collision-test-{}", std::process::id());
+        let dir = session_dir(&name);
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join("state.json"), "{}").unwrap();
+
+        let result = unique_session_name(&name);
+        assert!(result.starts_with(&format!("{name}-")));
+        assert_eq!(result.len(), name.len() + 1 + 6);
+
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
     #[test]
     fn custom_workflow_fields_round_trip_with_opaque_state() {
         let mut state = sample_state();
@@ -180,6 +208,29 @@ pub struct CreatedSessionState {
     pub lock_created: bool,
 }
 
+fn session_suffix() -> String {
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+    let seed = nanos ^ (std::process::id() as u128);
+    let mut n = seed;
+    const ALPHABET: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";
+    let mut buf = [0u8; 6];
+    for byte in &mut buf {
+        *byte = ALPHABET[(n % 36) as usize];
+        n /= 36;
+    }
+    String::from_utf8_lossy(&buf).into_owned()
+}
+
+pub fn unique_session_name(base: &str) -> String {
+    if !session_dir(base).join("state.json").exists() {
+        return base.to_string();
+    }
+    format!("{}-{}", base, session_suffix())
+}
+
 pub fn create_session_state(name: &str, mut state: SessionState) -> Result<CreatedSessionState> {
     ensure_rally_home()?;
     let dir = session_dir(name);