Method handle_session_end

atomic-agent/src/turn/orchestrator/session_end.rs:20–186

Handle a SessionEnd event. Transitions the session to Ended, saves it, and creates an attestation covering all changes recorded during the session. The attestation is a graph-level audit node — it captures agent identity, timing, and which changes were recorded. Cost and token data are left at zero (they're not available from the hook) and can be enriched later via `atomic agent attest --enrich`

(
        &mut self,
        event: TurnEvent,
    )

    /// data are left at zero (they're not available from the hook) and
    /// can be enriched later via `atomic agent attest --enrich`.
    pub(super) async fn handle_session_end(
        &mut self,
        event: TurnEvent,
    ) -> AgentResult<DispatchResult> {
        let session_id = &event.session_id;

        let mut session = match self.session_store.load(session_id)? {
            Some(s) => s,
            None => {
                // Session not found — nothing to end
                log::info!("SessionEnd for unknown session {} — ignoring", session_id);
                return Ok(DispatchResult::new(session_id, Phase::Ended));
            }
        };

        // If a turn is still active, cancel the watcher
        if session.is_turn_active() {
            if let Err(e) = self.watcher.cancel_turn().await {
                log::warn!(
                    "Failed to cancel turn watcher for session {}: {}",
                    session_id,
                    e
                );
            }
        }

        // Flush any unrecorded turn BEFORE finalizing. Headless agents such as
        // Cursor's CLI fire sessionStart/postToolUse/sessionEnd but no per-turn
        // `stop` (TurnEnd), so the turn's file changes are still uncommitted at
        // session end. Record them now — crucially *before* switching back to
        // the parent view below, which restores the working copy and would
        // otherwise discard the agent's work. Idempotent: agents that already
        // recorded each turn on `stop` leave a clean working copy here, so
        // `record_turn` returns `EmptyTurn` and this is a no-op for them.
        {
            // Ensure the working copy is on the session's agent view before
            // recording. session-start aligns to it, but that can drift back to
            // the parent view by session end (observed with Cursor's CLI), which
            // makes `record_turn` see a view mismatch and record nothing. Align
            // explicitly so the agent's uncommitted files are recorded on the
            // agent view. Best-effort — non-fatal if it can't switch.
            match atomic_repository::Repository::open_existing(&self.repo_root) {
                Ok(mut repo) => {
                    if repo.current_view() != session.view_name {
                        if let Err(e) = repo.align_to_view(&session.view_name) {
                            log::warn!(
                                "SessionEnd: could not align to agent view '{}': {} (non-fatal)",
                                session.view_name,
                                e,
                            );
                        } else {
                            log::info!(
                                "SessionEnd: aligned working copy to agent view '{}' before flush",
                                session.view_name,
                            );
                        }
                    }
                }