Method handle_session_end

atomic-agent/src/turn/orchestrator/session_end.rs:24–199

Handle a SessionEnd event. Transitions the session to Ended, saves it, and creates an attestation covering all changes recorded during the session. The working copy stays on the session's agent view so the user lands where the work happened and can review it before inserting it into a shared view. The attestation is a graph-level audit node — it captures agent identity, timing, and which change

(
        &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. 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.
            // Doubles as the "is there a worktree to protect?" answer for the
            // failed-flush guard below, which is why it is captured rather
            // than discarded. See there.
            let has_worktree = 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,
                            );
                        }
                    }