fix(cli): prevent self-destruction via --all commands (#600)

When honryu (or any agent) runs `kild stop --all` or `kild destroy --all`
from inside its own session, it now skips itself and prints a note. Explicit
single-branch commands (`kild stop honryu`) still work but print a warning.

Changes:
- Add `resolve_self_branch()` helper using $KILD_SESSION_BRANCH + CWD fallback
- Filter calling session from stop --all and destroy --all loops
- Add self-targeting warnings for explicit stop/destroy commands
- Add unit tests for resolve_self_branch()

Fixes #600

Author: Wirasm

crates/kild/src/commands/destroy.rs

@@ -23,6 +23,21 @@ pub(crate) fn handle_destroy_command(
         .get_one::<String>("branch")
         .ok_or("Branch argument is required (or use --all)")?;
 
+    // Warn if destroying own session
+    if let Some(self_br) = super::helpers::resolve_self_branch()
+        && self_br == branch.as_str()
+    {
+        eprintln!(
+            "{} You are about to destroy your own session ({}).",
+            color::warning("Warning:"),
+            color::ice(branch),
+        );
+        eprintln!(
+            "  {}",
+            color::hint("This will kill the agent and remove the session."),
+        );
+    }
+
     info!(
         event = "cli.destroy_started",
         branch = branch,
@@ -108,10 +123,25 @@ pub(crate) fn handle_destroy_command(
 fn handle_destroy_all(force: bool) -> Result<(), Box<dyn std::error::Error>> {
     info!(event = "cli.destroy_all_started", force = force);
 
-    let sessions = session_ops::list_sessions()?;
+    let self_branch = super::helpers::resolve_self_branch();
+
+    let mut sessions = session_ops::list_sessions()?;
+
+    // Filter out the calling session to prevent self-destruction
+    let skipped_self = if let Some(ref self_br) = self_branch {
+        let before = sessions.len();
+        sessions.retain(|s| s.branch.as_ref() != self_br.as_str());
+        before > sessions.len()
+    } else {
+        false
+    };
 
     if sessions.is_empty() {
-        println!("No kilds to destroy.");
+        if skipped_self {
+            println!("No other kilds to destroy (skipped self).");
+        } else {
+            println!("No kilds to destroy.");
+        }
         info!(
             event = "cli.destroy_all_completed",
             destroyed = 0,
@@ -120,6 +150,19 @@ fn handle_destroy_all(force: bool) -> Result<(), Box<dyn std::error::Error>> {
         return Ok(());
     }
 
+    if skipped_self && let Some(ref self_br) = self_branch {
+        info!(
+            event = "cli.destroy_all_self_skipped",
+            branch = self_br.as_str()
+        );
+        eprintln!(
+            "{} Skipping self ({}) — use `kild destroy {}` explicitly.",
+            color::warning("Note:"),
+            color::ice(self_br),
+            self_br,
+        );
+    }
+
     // Confirmation prompt unless --force is specified
     if !force {
         use std::io::{self, Write};

crates/kild/src/commands/helpers.rs

@@ -9,6 +9,25 @@ use kild_core::{events, session_ops};
 use super::json_types::JsonError;
 use crate::color;
 
+/// Resolve the branch name of the calling session, if running inside one.
+///
+/// Tries `$KILD_SESSION_BRANCH` first (reliable for claude/codex agents),
+/// then falls back to CWD-based worktree path matching (universal).
+/// Returns `None` when called from outside any kild session.
+pub(crate) fn resolve_self_branch() -> Option<String> {
+    // Fast path: env var is set for claude and codex daemon sessions
+    if let Ok(branch) = std::env::var("KILD_SESSION_BRANCH")
+        && !branch.is_empty()
+    {
+        return Some(branch);
+    }
+
+    // Fallback: match CWD against session worktree paths
+    let cwd = std::env::current_dir().ok()?;
+    let session = session_ops::find_session_by_worktree_path(&cwd).ok()??;
+    Some(session.branch.to_string())
+}
+
 /// Print a JSON error object to stdout for --json mode.
 /// Returns the error wrapped in Box for chaining with `return Err(...)`.
 pub fn print_json_error(error: &dyn std::fmt::Display, code: &str) -> Box<dyn std::error::Error> {
@@ -220,6 +239,61 @@ pub fn resolve_open_mode(matches: &clap::ArgMatches) -> kild_core::OpenMode {
 mod tests {
     use super::*;
 
+    /// # Safety helper — save/restore env var around test
+    unsafe fn set_env(key: &str, val: &str) {
+        unsafe { std::env::set_var(key, val) };
+    }
+    unsafe fn remove_env(key: &str) {
+        unsafe { std::env::remove_var(key) };
+    }
+    unsafe fn restore_env(key: &str, prev: Option<String>) {
+        match prev {
+            Some(v) => unsafe { std::env::set_var(key, v) },
+            None => unsafe { std::env::remove_var(key) },
+        }
+    }
+
+    #[test]
+    fn resolve_self_branch_from_env_var() {
+        let key = "KILD_SESSION_BRANCH";
+        let prev = std::env::var(key).ok();
+        // SAFETY: test-only, single-threaded test runner
+        unsafe { set_env(key, "honryu") };
+
+        let result = resolve_self_branch();
+        assert_eq!(result.as_deref(), Some("honryu"));
+
+        unsafe { restore_env(key, prev) };
+    }
+
+    #[test]
+    fn resolve_self_branch_empty_env_var() {
+        let key = "KILD_SESSION_BRANCH";
+        let prev = std::env::var(key).ok();
+        // SAFETY: test-only, single-threaded test runner
+        unsafe { set_env(key, "") };
+
+        let result = resolve_self_branch();
+        // Empty env var falls through; CWD is unlikely to match a session
+        assert_eq!(result, None);
+
+        unsafe { restore_env(key, prev) };
+    }
+
+    #[test]
+    fn resolve_self_branch_no_env_var() {
+        let key = "KILD_SESSION_BRANCH";
+        let prev = std::env::var(key).ok();
+        // SAFETY: test-only, single-threaded test runner
+        unsafe { remove_env(key) };
+
+        let result = resolve_self_branch();
+        // No env var and CWD is not a session worktree → None
+        assert_eq!(result, None);
+
+        unsafe { restore_env(key, prev) };
+    }
+
     #[test]
     fn test_load_config_with_warning_returns_valid_config() {
         // When config loads (successfully or with fallback), should return a valid config

crates/kild/src/commands/stop.rs

@@ -26,6 +26,21 @@ pub(crate) fn handle_stop_command(matches: &ArgMatches) -> Result<(), Box<dyn st
         .get_one::<String>("branch")
         .ok_or("Branch argument is required (or use --all)")?;
 
+    // Warn if stopping own session (prevents accidental self-destruction)
+    if let Some(self_br) = super::helpers::resolve_self_branch()
+        && self_br == branch.as_str()
+    {
+        eprintln!(
+            "{} You are about to stop your own session ({}).",
+            color::warning("Warning:"),
+            color::ice(branch),
+        );
+        eprintln!(
+            "  {}",
+            color::hint("This will kill the agent running this command."),
+        );
+    }
+
     info!(event = "cli.stop_started", branch = branch);
 
     match session_ops::stop_session(branch) {
@@ -100,18 +115,41 @@ fn handle_stop_teammate(branch: &str, pane_id: &str) -> Result<(), Box<dyn std::
 fn handle_stop_all() -> Result<(), Box<dyn std::error::Error>> {
     info!(event = "cli.stop_all_started");
 
+    let self_branch = super::helpers::resolve_self_branch();
+
     let sessions = session_ops::list_sessions()?;
     let mut active = Vec::new();
     let mut already_stopped = Vec::new();
+    let mut skipped_self = false;
 
     for s in sessions {
+        // Skip the calling session to prevent self-destruction
+        if let Some(ref self_br) = self_branch
+            && s.branch.as_ref() == self_br.as_str()
+        {
+            skipped_self = true;
+            continue;
+        }
         match s.status {
             SessionStatus::Active => active.push(s),
             SessionStatus::Stopped => already_stopped.push(s),
             _ => {}
         }
     }
 
+    if skipped_self && let Some(ref self_br) = self_branch {
+        info!(
+            event = "cli.stop_all_self_skipped",
+            branch = self_br.as_str()
+        );
+        eprintln!(
+            "{} Skipping self ({}) — use `kild stop {}` explicitly.",
+            color::warning("Note:"),
+            color::ice(self_br),
+            self_br,
+        );
+    }
+
     if active.is_empty() && already_stopped.is_empty() {
         println!("No running kilds to stop.");
         info!(event = "cli.stop_all_completed", stopped = 0, failed = 0);