Method handle_turn_end

atomic-agent/src/turn/orchestrator/turn.rs:128–448

Handle a TurnEnd event (Stop). Records an Atomic change for the turn (status → add → record), then transitions the session back to Idle. The recording workflow lets the repository figure out what changed: 1. `repo.status()` — find modified, deleted, and untracked files 2. `repo.add()` — track any new files the agent created 3. `repo.record(all: true)` — record everything that's dirty This avoid

(
        &mut self,
        mut event: TurnEvent,
    )

    /// snapshots between TurnStart and TurnEnd. Instead, we ask the
    /// repository what changed since the last recorded state.
    pub(super) async fn handle_turn_end(
        &mut self,
        mut event: TurnEvent,
    ) -> AgentResult<DispatchResult> {
        // Clone so `event` stays mutable for enrichment below while the
        // id is borrowed throughout this function.
        let session_id_owned = event.session_id.clone();
        let session_id = session_id_owned.as_str();
        let _turn_end_lock = match self.try_turn_end_lock(session_id) {
            TurnEndLock::Acquired(guard) => Some(guard),
            TurnEndLock::Busy => {
                log::warn!(
                    "Turn end for session {} is already being recorded; skipping duplicate Stop hook",
                    session_id
                );
                return Ok(DispatchResult::new(session_id, phase::Phase::Idle)
                    .with_warning("duplicate Stop hook skipped: turn already recording"));
            }
            TurnEndLock::Unavailable => None,
        };

        // The session lock deduplicates one session's Stops. Independent
        // sessions (including sandboxes) still share pristine and must not
        // race status/add/record or checkpoint publication. Acquire before
        // reading session/status, and retain through publication and save.
        let _publication_lock = self.wait_turn_publication_lock(session_id)?;

        let mut session = self.load_or_create_session(session_id, &event)?;

        // Tool hooks can reserve and populate the next journal turn without
        // a TurnStart (e.g. programmatic OpenCode/subagent turns). Consult that
        // durable state before classifying an idle session's Stop as a retry.
        if session.phase == phase::Phase::Idle {
            if let Some(sink) = &self.journal_sink {
                let pending = sink
                    .turn_status(session_id, session.turn_count.saturating_add(1))
                    .map_err(|reason| AgentError::ProvenanceJournalFailed {
                        session_id: session_id.to_owned(),
                        reason,
                    })?;
                if let Some(pending) = pending {
                    match pending.lifecycle {
                        JournalTurnLifecycle::Running | JournalTurnLifecycle::Checkpointing => {
                            session.begin_turn();
                            let transition = phase::transition(
                                session.phase,
                                Event::TurnStart,
                                TransitionContext::default(),
                            );
                            phase::apply_common_actions(&mut session, &transition);
                            // Persist activation before recording or publication so
                            // a failed checkpoint retains the normal retry path.
                            self.session_store.save(&session)?;
                        }
                        lifecycle => {
                            return Err(AgentError::ProvenanceJournalFailed {
                                session_id: session_id.to_owned(),
                                reason: format!(