会话恢复与外部操作核实

pub(super) async fn save_committed(
    surface: &SessionSurface,
    checkpoint: &CheckpointState,
    attempted_seq: &AtomicU64,
) -> Result<(), ActorError> {
    let facts = surface_fact_log(surface)?.read(&thread_for_session(&surface.session_id))?;
    replay_unsettled_mutations_from_facts(surface, &facts);
    let debt = receipts::fold_debt(&facts);
    let expected_binding = checkpoint
        .capability_binding
        .as_ref()
        .map(|binding| {
            crate::content_digest::digest_json("a3s.code.tool-admission-binding.v1", binding)
                .map_err(|error| ActorError::Schema(error.to_string()))
        })
        .transpose()?;
    let thread = thread_for_session(&surface.session_id);
    // A recovery may read receipts from its source Run. Export only when
    // this exact admitted Run has added a terminal; the original checkpoint
    // and log remain the authority for its older work.
    let latest = facts.iter().rev().find(|fact| {
        if fact.kind != "tool.result" {
            return false;
        }

pub(super) const RECOVERY_UNPROVED_FACT_KIND: &str = "recovery.unproved";
const RECOVERY_UNPROVED_SCHEMA: &str = "a3s.code.recovery-unproved.v1";
const RECOVERY_UNPROVED_IDENTITY_DOMAIN: &str = "a3s.code.recovery-unproved.identity.v1";
const SOURCE_BINDING_DIGEST_DOMAIN: &str = "a3s.code.tool-admission-binding.v1";

#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub(super) enum RecoveryUnprovedError {
    #[error("tool_effect_recovery_unproved_invalid: {0}")]
    Invalid(String),
    #[error("tool_effect_recovery_unproved_schema_unsupported: {0}")]
    SchemaUnsupported(String),
}

impl RecoveryUnprovedError {
    pub(super) const fn code(&self) -> &'static str {
        match self {
            Self::Invalid(_) => "tool_effect_recovery_unproved_invalid",
            Self::SchemaUnsupported(_) => "tool_effect_recovery_unproved_schema_unsupported",
        }

    pub fn reconcile_goal_slices(&self) -> Result<usize> {
        self.close_handle.mutate_immediate(|| {
            let lease = self.run_admission.try_acquire(&self.session_id)?;
            let log = lease.nonexecuting_fact_log(&self.run_admission, &self.session_id)?;
            let _writer = log.try_writer_fence().map_err(goal_log_error)?;
            let thread = crate::fact_control::thread_for_session(&self.session_id);
            let facts = log.read(&thread).map_err(goal_log_error)?;
            self.verify_saved_source(&facts)?;
            let digest = self.policy_digest_from(&facts)?;
            let workspace = self.tool_context.workspace_services.workspace_ref();
            let pending = crate::goal_control::reconcile_slices(
                &facts,
                &self.session_id,
                workspace,
                digest.as_deref(),
            )
            .map_err(goal_error)?;
            if !pending.is_empty() {
                log.append(&thread, &pending, None)
                    .map_err(goal_log_error)?;
            }
            let facts = log.read(&thread).map_err(goal_log_error)?;
            let completed = crate::goal_control::prepare_completion(
                &facts,
                &self.session_id,
                workspace,
                digest.as_deref(),
            )
            .map_err(goal_error)?;