An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.
Rust
omx(team): auto-checkpoint worker-2 [3]
bellmanf4e08d0ecf73
diff --git a/rust/crates/runtime/src/lib.rs b/rust/crates/runtime/src/lib.rsindex 70dba29b..2d18c744 100644--- a/rust/crates/runtime/src/lib.rs+++ b/rust/crates/runtime/src/lib.rs@@ -120,8 +120,10 @@ pub use oauth::{PkceChallengeMethod, PkceCodePair,};pub use permissions::{- PermissionContext, PermissionMode, PermissionOutcome, PermissionOverride, PermissionPolicy,- PermissionPromptDecision, PermissionPrompter, PermissionRequest,+ ApprovalDelegationHop, ApprovalScope, ApprovalTokenAudit, ApprovalTokenError,+ ApprovalTokenGrant, ApprovalTokenLedger, ApprovalTokenStatus, PermissionContext, PermissionMode,+ PermissionOutcome, PermissionOverride, PermissionPolicy, PermissionPromptDecision,+ PermissionPrompter, PermissionRequest,};pub use plugin_lifecycle::{DegradedMode, DiscoveryResult, PluginHealthcheck, PluginLifecycle, PluginLifecycleEvent,diff --git a/rust/crates/runtime/src/permissions.rs b/rust/crates/runtime/src/permissions.rsindex ca513970..f2046310 100644--- a/rust/crates/runtime/src/permissions.rs+++ b/rust/crates/runtime/src/permissions.rs@@ -12,6 +12,150 @@ pub struct ApprovalScope {pub action: String,pub repository: Option<String>,pub branch: Option<String>,++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}impl ApprovalScope {@@ -36,6 +180,150 @@ impl ApprovalScope {self.branch = Some(branch.into());self}++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}/// Actor/session hop recorded when an approval is delegated or consumed.@@ -44,6 +332,150 @@ pub struct ApprovalDelegationHop {pub actor: String,pub session_id: Option<String>,pub reason: String,++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}impl ApprovalDelegationHop {@@ -61,6 +493,150 @@ impl ApprovalDelegationHop {self.session_id = Some(session_id.into());self}++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}/// Current lifecycle state for a policy-exception approval token.@@ -71,6 +647,150 @@ pub enum ApprovalTokenStatus {Consumed,Expired,Revoked,++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}impl ApprovalTokenStatus {@@ -84,22 +804,310 @@ impl ApprovalTokenStatus {Self::Revoked => "approval_revoked",}}-}-/// Typed policy errors returned when a token cannot authorize a blocked action.-#[derive(Debug, Clone, PartialEq, Eq)]-pub enum ApprovalTokenError {- NoApproval,- ApprovalPending,- ApprovalExpired,- ApprovalRevoked,- ApprovalAlreadyConsumed,- ScopeMismatch { expected: ApprovalScope, actual: ApprovalScope },- UnauthorizedDelegate { expected: String, actual: String },-}+ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));-impl ApprovalTokenError {- #[must_use]+ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }++}++/// Typed policy errors returned when a token cannot authorize a blocked action.+#[derive(Debug, Clone, PartialEq, Eq)]+pub enum ApprovalTokenError {+ NoApproval,+ ApprovalPending,+ ApprovalExpired,+ ApprovalRevoked,+ ApprovalAlreadyConsumed,+ ScopeMismatch { expected: ApprovalScope, actual: ApprovalScope },+ UnauthorizedDelegate { expected: String, actual: String },++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }++}++impl ApprovalTokenError {+ #[must_use]pub fn as_str(&self) -> &'static str {match self {Self::NoApproval => "no_approval",@@ -111,6 +1119,150 @@ impl ApprovalTokenError {Self::UnauthorizedDelegate { .. } => "approval_unauthorized_delegate",}}++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}/// Approval grant bound to a policy/action scope, approving owner, and executor.@@ -125,6 +1277,150 @@ pub struct ApprovalTokenGrant {pub max_uses: u32,pub uses: u32,delegation_chain: Vec<ApprovalDelegationHop>,++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}impl ApprovalTokenGrant {@@ -186,6 +1482,150 @@ impl ApprovalTokenGrant {pub fn delegation_chain(&self) -> &[ApprovalDelegationHop] {&self.delegation_chain}++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}/// Auditable result of verifying or consuming an approval token.@@ -200,12 +1640,300 @@ pub struct ApprovalTokenAudit {pub delegation_chain: Vec<ApprovalDelegationHop>,pub uses: u32,pub max_uses: u32,-}-/// In-memory approval-token ledger with one-time-use and replay protection.-#[derive(Debug, Clone, PartialEq, Eq, Default)]-pub struct ApprovalTokenLedger {+ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }++}++/// In-memory approval-token ledger with one-time-use and replay protection.+#[derive(Debug, Clone, PartialEq, Eq, Default)]+pub struct ApprovalTokenLedger {grants: BTreeMap<String, ApprovalTokenGrant>,++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}impl ApprovalTokenLedger {@@ -334,6 +2062,150 @@ impl ApprovalTokenLedger {max_uses: grant.max_uses,}}++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}/// Permission level assigned to a tool invocation or runtime session.@@ -344,6 +2216,150 @@ pub enum PermissionMode {DangerFullAccess,Prompt,Allow,++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}impl PermissionMode {@@ -357,6 +2373,150 @@ impl PermissionMode {Self::Allow => "allow",}}++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}/// Hook-provided override applied before standard permission evaluation.@@ -365,18 +2525,306 @@ pub enum PermissionOverride {Allow,Deny,Ask,-}-/// Additional permission context supplied by hooks or higher-level orchestration.-#[derive(Debug, Clone, PartialEq, Eq, Default)]-pub struct PermissionContext {- override_decision: Option<PermissionOverride>,- override_reason: Option<String>,-}+ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));-impl PermissionContext {- #[must_use]- pub fn new(+ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }++}++/// Additional permission context supplied by hooks or higher-level orchestration.+#[derive(Debug, Clone, PartialEq, Eq, Default)]+pub struct PermissionContext {+ override_decision: Option<PermissionOverride>,+ override_reason: Option<String>,++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }++}++impl PermissionContext {+ #[must_use]+ pub fn new(override_decision: Option<PermissionOverride>,override_reason: Option<String>,) -> Self {@@ -395,6 +2843,150 @@ impl PermissionContext {pub fn override_reason(&self) -> Option<&str> {self.override_reason.as_deref()}++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}/// Full authorization request presented to a permission prompt.@@ -405,6 +2997,150 @@ pub struct PermissionRequest {pub current_mode: PermissionMode,pub required_mode: PermissionMode,pub reason: Option<String>,++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}/// User-facing decision returned by a [`PermissionPrompter`].@@ -412,28 +3148,604 @@ pub struct PermissionRequest {pub enum PermissionPromptDecision {Allow,Deny { reason: String },++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}/// Prompting interface used when policy requires interactive approval.pub trait PermissionPrompter {fn decide(&mut self, request: &PermissionRequest) -> PermissionPromptDecision;++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }++}++/// Final authorization result after evaluating static rules and prompts.+#[derive(Debug, Clone, PartialEq, Eq)]+pub enum PermissionOutcome {+ Allow,+ Deny { reason: String },++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}-/// Final authorization result after evaluating static rules and prompts.-#[derive(Debug, Clone, PartialEq, Eq)]-pub enum PermissionOutcome {- Allow,- Deny { reason: String },-}+/// Evaluates permission mode requirements plus allow/deny/ask rules.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct PermissionPolicy {+ active_mode: PermissionMode,+ tool_requirements: BTreeMap<String, PermissionMode>,+ allow_rules: Vec<PermissionRule>,+ deny_rules: Vec<PermissionRule>,+ ask_rules: Vec<PermissionRule>,++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }-/// Evaluates permission mode requirements plus allow/deny/ask rules.-#[derive(Debug, Clone, PartialEq, Eq)]-pub struct PermissionPolicy {- active_mode: PermissionMode,- tool_requirements: BTreeMap<String, PermissionMode>,- allow_rules: Vec<PermissionRule>,- deny_rules: Vec<PermissionRule>,- ask_rules: Vec<PermissionRule>,}impl PermissionPolicy {@@ -662,6 +3974,150 @@ impl PermissionPolicy {) -> Option<&'a PermissionRule> {rules.iter().find(|rule| rule.matches(tool_name, input))}++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}#[derive(Debug, Clone, PartialEq, Eq)]@@ -669,6 +4125,150 @@ struct PermissionRule {raw: String,tool_name: String,matcher: PermissionRuleMatcher,++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}#[derive(Debug, Clone, PartialEq, Eq)]@@ -676,6 +4276,150 @@ enum PermissionRuleMatcher {Any,Exact(String),Prefix(String),++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}impl PermissionRule {@@ -720,17 +4464,305 @@ impl PermissionRule {.is_some_and(|candidate| candidate.starts_with(prefix)),}}++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}-fn parse_rule_matcher(content: &str) -> PermissionRuleMatcher {- let unescaped = unescape_rule_content(content.trim());- if unescaped.is_empty() || unescaped == "*" {- PermissionRuleMatcher::Any- } else if let Some(prefix) = unescaped.strip_suffix(":*") {- PermissionRuleMatcher::Prefix(prefix.to_string())- } else {- PermissionRuleMatcher::Exact(unescaped)+fn parse_rule_matcher(content: &str) -> PermissionRuleMatcher {+ let unescaped = unescape_rule_content(content.trim());+ if unescaped.is_empty() || unescaped == "*" {+ PermissionRuleMatcher::Any+ } else if let Some(prefix) = unescaped.strip_suffix(":*") {+ PermissionRuleMatcher::Prefix(prefix.to_string())+ } else {+ PermissionRuleMatcher::Exact(unescaped)+ }++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));}+}fn unescape_rule_content(content: &str) -> String {@@ -738,6 +4770,150 @@ fn unescape_rule_content(content: &str) -> String {.replace(r"\(", "(").replace(r"\)", ")").replace(r"\\", r"\")++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}fn find_first_unescaped(value: &str, needle: char) -> Option<usize> {@@ -753,6 +4929,150 @@ fn find_first_unescaped(value: &str, needle: char) -> Option<usize> {escaped = false;}None++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}fn find_last_unescaped(value: &str, needle: char) -> Option<usize> {@@ -774,6 +5094,150 @@ fn find_last_unescaped(value: &str, needle: char) -> Option<usize> {}}None++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}fn extract_permission_subject(input: &str) -> Option<String> {@@ -798,13 +5262,159 @@ fn extract_permission_subject(input: &str) -> Option<String> {}(!input.trim().is_empty()).then(|| input.to_string())++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}#[cfg(test)]mod tests {use super::{- PermissionContext, PermissionMode, PermissionOutcome, PermissionOverride, PermissionPolicy,- PermissionPromptDecision, PermissionPrompter, PermissionRequest,+ ApprovalDelegationHop, ApprovalScope, ApprovalTokenError, ApprovalTokenGrant,+ ApprovalTokenLedger, ApprovalTokenStatus, PermissionContext, PermissionMode,+ PermissionOutcome, PermissionOverride, PermissionPolicy, PermissionPromptDecision,+ PermissionPrompter, PermissionRequest,};use crate::config::RuntimePermissionRuleConfig;@@ -1012,4 +5622,148 @@ mod tests {Some("hook requested confirmation"));}++ #[test]+ fn approval_token_blocks_until_owner_grants_policy_exception() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ ledger.insert(ApprovalTokenGrant::pending(+ "tok-pending",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));++ assert!(matches!(+ ledger.verify("tok-missing", &scope, "release-bot", 10),+ Err(ApprovalTokenError::NoApproval)+ ));+ assert!(matches!(+ ledger.verify("tok-pending", &scope, "release-bot", 10),+ Err(ApprovalTokenError::ApprovalPending)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-granted",+ scope.clone(),+ "repo-owner",+ "release-bot",+ ));+ let audit = ledger+ .verify("tok-granted", &scope, "release-bot", 10)+ .expect("owner approval should verify");++ assert_eq!(audit.status, ApprovalTokenStatus::Granted);+ assert_eq!(audit.approving_actor, "repo-owner");+ assert_eq!(audit.executing_actor, "release-bot");+ assert!(audit.delegated_execution);+ }++ #[test]+ fn approval_token_is_one_time_use_and_rejects_replay() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("release_requires_owner", "release publish")+ .with_repository("sisyphus/claw-code");+ ledger.insert(ApprovalTokenGrant::granted(+ "tok-once",+ scope.clone(),+ "owner",+ "release-bot",+ ));++ let first = ledger+ .consume("tok-once", &scope, "release-bot", 10)+ .expect("first use should consume token");+ assert_eq!(first.status, ApprovalTokenStatus::Consumed);+ assert_eq!(first.uses, 1);++ assert!(matches!(+ ledger.consume("tok-once", &scope, "release-bot", 11),+ Err(ApprovalTokenError::ApprovalAlreadyConsumed)+ ));+ assert_eq!(+ ledger.get("tok-once").map(|grant| grant.status),+ Some(ApprovalTokenStatus::Consumed)+ );+ }++ #[test]+ fn approval_token_rejects_scope_expansion_expiry_and_revocation() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("main");+ let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")+ .with_repository("sisyphus/claw-code")+ .with_branch("dev");++ ledger.insert(+ ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")+ .expires_at(20),+ );++ assert!(matches!(+ ledger.verify("tok-expiring", &dev_scope, "bot", 10),+ Err(ApprovalTokenError::ScopeMismatch { .. })+ ));+ assert!(matches!(+ ledger.verify("tok-expiring", &scope, "bot", 21),+ Err(ApprovalTokenError::ApprovalExpired)+ ));++ ledger.insert(ApprovalTokenGrant::granted(+ "tok-revoked",+ scope.clone(),+ "owner",+ "bot",+ ));+ let revoked = ledger+ .revoke("tok-revoked")+ .expect("revocation should be audited");+ assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);+ assert!(matches!(+ ledger.verify("tok-revoked", &scope, "bot", 10),+ Err(ApprovalTokenError::ApprovalRevoked)+ ));+ }++ #[test]+ fn approval_token_preserves_delegation_traceability() {+ let mut ledger = ApprovalTokenLedger::new();+ let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");+ ledger.insert(+ ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")+ .with_delegation_hop(+ ApprovalDelegationHop::new("owner", "owner approval")+ .with_session_id("session-owner"),+ )+ .with_delegation_hop(+ ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")+ .with_session_id("session-lead"),+ ),+ );++ assert!(matches!(+ ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),+ Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })+ if expected == "deploy-bot" && actual == "unexpected-bot"+ ));++ let audit = ledger+ .consume("tok-delegated", &scope, "deploy-bot", 10)+ .expect("approved delegate should consume token");+ let actors = audit+ .delegation_chain+ .iter()+ .map(|hop| hop.actor.as_str())+ .collect::<Vec<_>>();++ assert!(audit.delegated_execution);+ assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);+ assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));+ assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));+ }+}