mind-self-run: the child's HUGINN_SESSION is its run's label

Spawner::spawn takes the session to export; the Self run gives the bare run label (the spelling the run's opening receipt carries). The Persona gives none.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

crates/mind-body/src/persona.rs

@@ -1006,7 +1006,7 @@ pub(crate) fn start_session(
         Ok(Lent::Granted(lease)) => lease,
         Ok(Lent::Refused(_)) | Err(_) => return Ok(Err(Failure::Lease)),
     };
-    let Ok(child) = organs.spawner.spawn(&persona_args(session_id, &config.model, &schema, &prompt), lease.token()) else { return Ok(Err(Failure::Session)) };
+    let Ok(child) = organs.spawner.spawn(&persona_args(session_id, &config.model, &schema, &prompt), lease.token(), None) else { return Ok(Err(Failure::Session)) };
     Ok(Ok(Started { child, lease, started_ms }))
 }
 

crates/mind-body/src/persona/tests.rs

@@ -247,7 +247,7 @@ struct FakeSession {
 }
 
 impl Spawner for FakeSession {
-    fn spawn(&self, args: &[String], _token: &TokenFd) -> Result<Box<dyn Child>> {
+    fn spawn(&self, args: &[String], _token: &TokenFd, _session: Option<&str>) -> Result<Box<dyn Child>> {
         if self.refuse.get() {
             return Err(anyhow!("refused"));
         }
@@ -2711,7 +2711,7 @@ impl Child for Timed {
 struct ScriptedSpawner<T>(RefCell<VecDeque<T>>);
 
 impl<T: Child + 'static> crate::self_run::Spawner for ScriptedSpawner<T> {
-    fn spawn(&self, _args: &[String], _token: &TokenFd) -> Result<Box<dyn Child>> {
+    fn spawn(&self, _args: &[String], _token: &TokenFd, _session: Option<&str>) -> Result<Box<dyn Child>> {
         self.0.borrow_mut().pop_front().map(|child| Box::new(child) as Box<dyn Child>).ok_or_else(|| anyhow!("no more processes"))
     }
 }

crates/mind-body/src/self_run.rs

@@ -150,6 +150,8 @@ const ENV_SCRUB_VARIABLE: &str = "CLAUDE_CODE_SUBPROCESS_ENV_SCRUB";
 /// Optional, set by the unit: `off` turns that scrub off for a run whose user holds root, where it
 /// protects nothing and its sandbox's no_new_privs would only stop `sudo`. Anything else keeps it on.
 const SCRUB_VARIABLE: &str = "MIND_SELF_SCRUB";
+/// The variable the child's `huginn` reads its `--session` from: the run's label, the id the start message names.
+const SESSION_VARIABLE: &str = "HUGINN_SESSION";
 /// The name the start message tells her to admit as.
 pub const AGENT: &str = "mind-self-run";
 /// The namespace of the session id: the run id is the name in it.
@@ -227,6 +229,12 @@ fn flush_text(why: Why) -> String {
     format!("{cause} {FLUSH_MESSAGE} Close each brief that is done by the closing rule; a brief whose change is not on its default branch stays open, or is superseded by your own follow-up when it waits on someone else, and the next session continues it.")
 }
 
+/// The label of a run, the last segment of its id (`<instance>:run:<label>`): what the opening receipt of every run already carries as its session
+/// (`launch::run_label`), so a `huginn` admission and the run's own receipts name one session in one spelling.
+fn run_label(run: &PipelineRef) -> &str {
+    run.id.0.rsplit(':').next().unwrap_or(&run.id.0)
+}
+
 /// The session id of a run: UUIDv5 over the run's id. Derived, never stored.
 pub fn session_id(run: &PipelineRef) -> Uuid {
     Uuid::new_v5(&SESSION_NAMESPACE, run.id.0.as_bytes())
@@ -464,8 +472,10 @@ pub struct Kept {
 }
 
 pub trait Spawner {
-    /// Starts the child with `token` as its credential descriptor.
-    fn spawn(&self, args: &[String], token: &TokenFd) -> Result<Box<dyn Child>>;
+    /// Starts the child with `token` as its credential descriptor and, when `session` is given, that label
+    /// as its `HUGINN_SESSION`: the session its `huginn` admissions are attributed to. A child with no run
+    /// label (the Persona's) is given none.
+    fn spawn(&self, args: &[String], token: &TokenFd, session: Option<&str>) -> Result<Box<dyn Child>>;
 
     /// The organ's one kept conversation, if any. A spawner that keeps nothing says none.
     fn kept(&self) -> Option<Kept> {
@@ -728,7 +738,7 @@ fn lend_and_drive(mind: &dyn MindPort, clock: &dyn Clock, lender: &dyn Lender, s
         heard.resumed = Some(kept.session);
         writeln!(out, "session resumed {} warm until {}", kept.session, kept.warm_until.to_rfc3339_opts(SecondsFormat::Secs, true))?;
     }
-    let child = spawner.spawn(&claude_args(session_id(run), resume.as_ref().map(|kept| kept.transcript.as_path())), lease.token())?;
+    let child = spawner.spawn(&claude_args(session_id(run), resume.as_ref().map(|kept| kept.transcript.as_path())), lease.token(), Some(run_label(run)))?;
     let mut inbox = SelfInbox::new(mind, (run, claims), task, (lease.plan_quota(), started_ms), (told, conversation), heard, resume.is_some());
     let ran = drive(clock, child, &mut inbox, run_cap_s, out);
     inbox.admit_unadmitted();
@@ -1090,13 +1100,13 @@ impl Spawner for ClaudeSpawner {
         clear_kept_dir(dir, &[KEPT_RECORD.to_string(), format!("{session}.jsonl")]).context("the conversation before it could not be removed")
     }
 
-    fn spawn(&self, args: &[String], token: &TokenFd) -> Result<Box<dyn Child>> {
+    fn spawn(&self, args: &[String], token: &TokenFd, session: Option<&str>) -> Result<Box<dyn Child>> {
         let config = FreshConfig::create(&self.scratch, self.seed.as_deref(), self.keep.clone())?;
-        let Some(sandbox) = &self.sandbox else { return spawn_program(Path::new("claude"), args, token, &self.unit_environment, config) };
+        let Some(sandbox) = &self.sandbox else { return spawn_program(Path::new("claude"), args, token, (&self.unit_environment, session), config) };
         let mut wrapped = sandbox_args(sandbox, &self.scratch);
         wrapped.push("claude".into());
         wrapped.extend(args.iter().cloned());
-        spawn_program(Path::new("bwrap"), &wrapped, token, &self.unit_environment, config)
+        spawn_program(Path::new("bwrap"), &wrapped, token, (&self.unit_environment, session), config)
     }
 }
 
@@ -1274,6 +1284,7 @@ fn copy_level(root: &Path, from: &Path, to: &Path) -> std::io::Result<()> {
 /// `CLAUDE_CONFIG_DIR` are its fresh configuration directory, set by the spawn.
 /// `EUREKA_INSTANCE` and `HUGINN_ENDPOINT` are the `huginn` CLI's whole identity
 /// (ruling `eureka-body:ruling:cli-over-mcp-agent-surface`): a name and an address, no secret.
+/// Its session, `HUGINN_SESSION`, is set by the spawn from the run, never passed through.
 fn child_may_see(name: &OsStr) -> bool {
     let name = name.to_string_lossy();
     matches!(name.as_ref(), "PATH" | "LANG" | "TERM" | "EUREKA_INSTANCE" | "HUGINN_ENDPOINT") || name.starts_with("LC_")
@@ -1295,13 +1306,17 @@ fn scrub_is_off(unit: &[(OsString, OsString)]) -> bool {
 /// token. `claude` reads it to the end once at startup, so what its own children
 /// inherit is an emptied pipe whose write end exists nowhere. The child's
 /// environment is cleared and rebuilt from `unit`'s allow-listed variables.
-fn spawn_program(program: &Path, args: &[String], token: &TokenFd, unit: &[(OsString, OsString)], config: FreshConfig) -> Result<Box<dyn Child>> {
+fn spawn_program(program: &Path, args: &[String], token: &TokenFd, (unit, session): (&[(OsString, OsString)], Option<&str>), config: FreshConfig) -> Result<Box<dyn Child>> {
     let inheritable = token.inheritable().context("the credential descriptor could not be placed")?;
     let mut command = Command::new(program);
     command.args(args).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::inherit());
     command.env_clear().envs(child_environment(unit));
     command.env("HOME", &config.dir).env(CONFIG_DIR_VARIABLE, &config.dir);
     command.env(DISABLE_COMPACT_VARIABLE, "1").env(TOKEN_FD_VARIABLE, inheritable.number().to_string()).env(ENV_SCRUB_VARIABLE, if scrub_is_off(unit) { "0" } else { "1" });
+    // The unit's own `HUGINN_SESSION` is not on the allow-list: the only value the child can hold is the one its run was given.
+    if let Some(session) = session {
+        command.env(SESSION_VARIABLE, session);
+    }
     // Its own process group, so that a signal reaches what the child started too.
     #[cfg(unix)]
     std::os::unix::process::CommandExt::process_group(&mut command, 0);

crates/mind-body/src/self_run/tests.rs

@@ -138,6 +138,7 @@ struct Ran {
     /// Every event, the lease's included.
     all: Vec<Event>,
     spawns: Vec<Vec<String>>,
+    sessions: Vec<Option<String>>,
     admits: usize,
     asked: Vec<LeaseRequest>,
 }
@@ -215,7 +216,8 @@ fn carry_kept(seen: &Seen, steps: Vec<Step>, (code, dies_on, refuses, hangs): (O
     // The child's own events; the lease's are in `all`, in order with them.
     let events = all.iter().filter(|event| !matches!(event, Event::Lent | Event::Spawned | Event::Abandoned | Event::Kept(_))).cloned().collect();
     let spawns = fake.spawns.borrow().clone();
-    Ran { outcome, out: String::from_utf8(out).unwrap(), events, all, spawns, admits: seen.admits.get(), asked: lender.asked.borrow().clone() }
+    let sessions = fake.sessions.borrow().clone();
+    Ran { outcome, out: String::from_utf8(out).unwrap(), events, all, spawns, sessions, admits: seen.admits.get(), asked: lender.asked.borrow().clone() }
 }
 
 fn at_start() -> chrono::DateTime<chrono::Utc> {
@@ -363,6 +365,26 @@ fn the_child_is_started_for_her_run_with_the_fixed_list_whatever_the_run_record_
     }
 }
 
+#[test]
+fn the_child_is_given_its_runs_label_as_huginn_session_fresh_resumed_and_in_the_next_run_only() {
+    // Fresh: the bare label, the spelling the run's opening receipt carries, not the id and not the derived UUID.
+    let a = with_run();
+    let fresh = carry_with(&Seen::of(&a), vec![Out(result_line())], Some(0), false);
+    assert_eq!(fresh.sessions, [Some("selfrun-a".to_string())]);
+    // Resumed: the same child, the new run's label.
+    let resumed = carry_kept(&Seen::of(&with_run()), vec![Out(result_line())], (Some(0), None, &[], false), Some(resume::kept_for(1800, true)));
+    assert_eq!(resumed.sessions, [Some("selfrun-a".to_string())]);
+    // The rotation's new run sets its own; nothing of the previous run is carried.
+    let b = TestMind::seeded();
+    b.committed(vec![self_run("selfrun-b", "5")]);
+    let next = carry_kept(&Seen::of(&b), vec![Out(result_line())], (Some(0), None, &[], false), Some(resume::kept_for(1800, true)));
+    assert_eq!(next.sessions, [Some("selfrun-b".to_string())]);
+    for ran in [&fresh, &resumed, &next] {
+        assert!(ran.sessions.iter().flatten().all(|label| !label.contains(':') && label.parse::<Uuid>().is_err()), "{:?}", ran.sessions);
+    }
+    assert!(!next.sessions.contains(&Some("selfrun-a".to_string())));
+}
+
 #[test]
 fn the_start_message_is_the_first_thing_written_and_names_the_skill_the_instance_and_the_run() {
     let ran = go(vec![Out(result_line())]);
@@ -962,7 +984,7 @@ mod process {
     fn start_with(program: &Path, args: &[String], token: &TokenFd) -> Box<dyn Child> {
         for _ in 0..50 {
             let config = FreshConfig::create(program.parent().unwrap(), None, None).unwrap();
-            match spawn_program(program, args, token, &unit_environment(), config) {
+            match spawn_program(program, args, token, (&unit_environment(), None), config) {
                 Ok(child) => return child,
                 Err(error) if format!("{error:#}").contains("busy") => std::thread::sleep(StdDuration::from_millis(100)),
                 Err(error) => panic!("{error:#}"),
@@ -1034,7 +1056,7 @@ mod process {
         let canary = "canary-argument-6b0d";
         let scratch = tempfile::tempdir().unwrap();
         let config = FreshConfig::create(scratch.path(), None, None).unwrap();
-        let error = spawn_program(Path::new("/nonexistent/claude"), &[canary.to_string()], &token_holding("tok-canary"), &[], config).err().unwrap();
+        let error = spawn_program(Path::new("/nonexistent/claude"), &[canary.to_string()], &token_holding("tok-canary"), (&[], None), config).err().unwrap();
         assert!(!format!("{error:#}").contains(canary) && !format!("{error:#}").contains("nonexistent"), "{error:#}");
     }
 
@@ -1061,7 +1083,7 @@ mod process {
 
     struct Spawn(PathBuf);
     impl Spawner for Spawn {
-        fn spawn(&self, args: &[String], token: &TokenFd) -> Result<Box<dyn Child>> {
+        fn spawn(&self, args: &[String], token: &TokenFd, _session: Option<&str>) -> Result<Box<dyn Child>> {
             Ok(Box::new(Prompt(start_with(&self.0, args, token))))
         }
     }
@@ -1087,7 +1109,7 @@ mod process {
 
     struct Patient(PathBuf);
     impl Spawner for Patient {
-        fn spawn(&self, args: &[String], token: &TokenFd) -> Result<Box<dyn Child>> {
+        fn spawn(&self, args: &[String], token: &TokenFd, _session: Option<&str>) -> Result<Box<dyn Child>> {
             Ok(Box::new(Bounded(start_with(&self.0, args, token), std::time::Instant::now())))
         }
     }
@@ -1942,7 +1964,7 @@ mod sandbox {
         unit.push(("PATH".into(), format!("{}:/usr/bin:/bin", bin.display()).into()));
         unit.push((SCRATCH_VARIABLE.into(), scratch.clone().into_os_string()));
         let spawner = ClaudeSpawner::in_sandbox(unit, "MIND_PERSONA_CONFIG_SEED", Some(sandbox.clone())).unwrap();
-        let mut child = spawner.spawn(&["--flag".to_string(), "value".to_string()], &token_holding("tok-canary")).unwrap();
+        let mut child = spawner.spawn(&["--flag".to_string(), "value".to_string()], &token_holding("tok-canary"), None).unwrap();
         while !matches!(child.next(StdDuration::from_secs(20)), Read::Exited(_) | Read::Timeout) {}
         let recorded: Vec<String> = std::fs::read_to_string(&argv).unwrap().lines().map(String::from).collect();
         let mut expected = sandbox_args(&sandbox, &scratch);

crates/mind-body/src/self_run/tests/process/lease_child.rs

@@ -91,7 +91,7 @@ echo left > "$CLAUDE_CONFIG_DIR/leftover"
 
 fn run_once(program: &Path, scratch: &Path, seed: Option<&Path>) -> Vec<String> {
     let config = FreshConfig::create(scratch, seed, None).unwrap();
-    let mut child = spawn_program(program, &[], &token_holding("tok-canary-7f3a"), &unit_environment(), config).unwrap();
+    let mut child = spawn_program(program, &[], &token_holding("tok-canary-7f3a"), (&unit_environment(), None), config).unwrap();
     child.close_input();
     let (lines, code) = drain(&mut *child);
     assert_eq!(code, Some(0), "{lines:?}");
@@ -167,7 +167,7 @@ fn the_child_scrubs_its_subprocesses_unless_the_unit_says_off() {
         let mut unit = unit_environment();
         unit.extend(value.map(|value| (SCRUB_VARIABLE.into(), value.into())));
         let config = FreshConfig::create(dir.path(), None, None).unwrap();
-        let mut child = spawn_program(&program, &[], &token_holding("tok-canary-7f3a"), &unit, config).unwrap();
+        let mut child = spawn_program(&program, &[], &token_holding("tok-canary-7f3a"), (&unit, None), config).unwrap();
         child.close_input();
         let (lines, _) = drain(&mut *child);
         field(&lines, "scrub")
@@ -177,3 +177,22 @@ fn the_child_scrubs_its_subprocesses_unless_the_unit_says_off() {
     assert_eq!(scrub_with(Some("OFF")), "1", "only the exact word turns it off");
     assert_eq!(scrub_with(Some("off")), "0", "a unit for a user that holds root turns it off");
 }
+
+#[test]
+fn the_child_holds_huginn_session_only_as_the_spawn_set_it_never_as_the_unit_had_it() {
+    let dir = tempfile::tempdir().unwrap();
+    let program = script(&dir, "echo \"session=${HUGINN_SESSION-unset}\"");
+    let session_of = |unit_value: Option<&str>, given: Option<&str>| {
+        let mut unit = unit_environment();
+        unit.extend(unit_value.map(|value| ("HUGINN_SESSION".into(), value.into())));
+        let config = FreshConfig::create(dir.path(), None, None).unwrap();
+        let mut child = spawn_program(&program, &[], &token_holding("tok-canary-7f3a"), (&unit, given), config).unwrap();
+        child.close_input();
+        let (lines, _) = drain(&mut *child);
+        field(&lines, "session")
+    };
+    assert_eq!(session_of(None, Some("mind-20261111T072944197Z")), "mind-20261111T072944197Z");
+    assert_eq!(session_of(None, None), "unset", "a child with no run label is given none");
+    assert_eq!(session_of(Some("stale-unit-value"), None), "unset", "the unit's own value is not on the allow-list");
+    assert_eq!(session_of(Some("stale-unit-value"), Some("mind-new")), "mind-new", "the run's label is the only value");
+}

crates/mind-body/src/self_run/tests/resume.rs

@@ -15,7 +15,7 @@ fn previous() -> Uuid {
     Uuid::parse_str(PREVIOUS).unwrap()
 }
 
-fn kept_for(warm_for_s: i64, same_seed: bool) -> Kept {
+pub(super) fn kept_for(warm_for_s: i64, same_seed: bool) -> Kept {
     Kept { session: previous(), transcript: PathBuf::from(format!("/state/session/{PREVIOUS}.jsonl")), warm_until: at_start() + ChronoDuration::seconds(warm_for_s), written_at: at_start(), same_seed }
 }
 
@@ -321,8 +321,8 @@ impl Spawner for FilesThenDies {
         self.files.keep(keep)
     }
 
-    fn spawn(&self, args: &[String], token: &TokenFd) -> Result<Box<dyn Child>> {
-        self.dies.spawn(args, token)
+    fn spawn(&self, args: &[String], token: &TokenFd, session: Option<&str>) -> Result<Box<dyn Child>> {
+        self.dies.spawn(args, token, session)
     }
 }
 

crates/mind-body/src/testkit.rs

@@ -660,6 +660,8 @@ impl Child for Scripted {
 pub(crate) struct Fake {
     pub(crate) child: RefCell<Option<Scripted>>,
     pub(crate) spawns: RefCell<Vec<Vec<String>>>,
+    /// The `HUGINN_SESSION` each spawn was given, in order with `spawns`.
+    pub(crate) sessions: RefCell<Vec<Option<String>>>,
     pub(crate) refuse: bool,
     /// The conversation the spawner reports as kept; a test sets it.
     pub(crate) kept: RefCell<Option<Kept>>,
@@ -670,7 +672,7 @@ pub(crate) struct Fake {
 impl Fake {
     pub(crate) fn with(child: Option<Scripted>, refuse: bool) -> Self {
         let log = child.as_ref().map(|child| child.log.clone());
-        Self { child: RefCell::new(child), spawns: RefCell::new(Vec::new()), refuse, kept: RefCell::new(None), log }
+        Self { child: RefCell::new(child), spawns: RefCell::new(Vec::new()), sessions: RefCell::new(Vec::new()), refuse, kept: RefCell::new(None), log }
     }
 }
 
@@ -686,8 +688,9 @@ impl Spawner for Fake {
         Ok(())
     }
 
-    fn spawn(&self, args: &[String], _token: &TokenFd) -> Result<Box<dyn Child>> {
+    fn spawn(&self, args: &[String], _token: &TokenFd, session: Option<&str>) -> Result<Box<dyn Child>> {
         self.spawns.borrow_mut().push(args.to_vec());
+        self.sessions.borrow_mut().push(session.map(str::to_string));
         if self.refuse {
             return Err(anyhow!("refused"));
         }

crates/mind-body/tests/public_surface.txt

@@ -308,7 +308,7 @@ mind_body::self_run: impl std :: error :: Error for SeedLinkRefused
 mind_body::self_run: impl< 'a > SelfInbox < 'a >
 mind_body::self_run: mod inbox
 mind_body::self_run: pub trait Child { fn write_line (& mut self , line : & str) ; fn close_input (& mut self) ; fn next (& mut self , timeout : StdDuration) -> Read ; fn stop (& mut self , how : Stop) -> bool ; }
-mind_body::self_run: pub trait Spawner { fn spawn (& self , args : & [String] , token : & TokenFd) -> Result < Box < dyn Child > > ; fn kept (& self) -> Option < Kept > { None } fn keep (& self , _keep : Option < (Uuid , DateTime < Utc >) >) -> Result < () > { Ok (()) } }
+mind_body::self_run: pub trait Spawner { fn spawn (& self , args : & [String] , token : & TokenFd , session : Option < & str >) -> Result < Box < dyn Child > > ; fn kept (& self) -> Option < Kept > { None } fn keep (& self , _keep : Option < (Uuid , DateTime < Utc >) >) -> Result < () > { Ok (()) } }
 mind_body::self_run: struct ClaudeSpawner  pub-fields[]
 mind_body::self_run: struct Kept # [derive (Clone , Debug , PartialEq , Eq)] pub-fields[session: Uuid, transcript: PathBuf, warm_until: DateTime < Utc >, written_at: DateTime < Utc >, same_seed: bool]
 mind_body::self_run::decide: impl State