use supercode_harness::{
ClaudeCronJob, ClaudeQueueState, ClaudeRuntimeExecutionState, ClaudeRuntimeManifest,
ClaudeRuntimePosture, ClaudeRuntimeSchedulerState, ClaudeRuntimeTriggerKind, ClaudeWakeup,
CLAUDE_RUNTIME_MANIFEST_VERSION,
};
const HOUR: i64 = 1_700_002_800;
const HOUR_RFC3339: &str = "2023-11-14T23:00:00.000Z";
fn manifest() -> ClaudeRuntimeManifest {
ClaudeRuntimeManifest {
schema_version: CLAUDE_RUNTIME_MANIFEST_VERSION,
execution_state: ClaudeRuntimeExecutionState::Paused,
scheduler: ClaudeRuntimeSchedulerState::default(),
posture: ClaudeRuntimePosture::default(),
active_crons: Vec::new(),
pending_wakeups: Vec::new(),
queue: ClaudeQueueState {
enqueued: 0,
dequeued: 0,
removed: 0,
pending: Vec::new(),
},
background_children: Vec::new(),
reported_pending_background_children: None,
residue: Vec::new(),
}
}
fn cron(id: &str, schedule: &str, recurring: bool) -> ClaudeCronJob {
ClaudeCronJob {
id: id.to_string(),
tool_use_id: format!("tool-{id}"),
schedule: schedule.to_string(),
recurring,
durable_requested: false,
prompt: format!("prompt-{id}"),
created_at: Some(HOUR_RFC3339.to_string()),
expires_after_seconds: None,
creation_result: "created".to_string(),
}
}
#[test]
fn real_fleet_jobs_claim_in_deadline_then_id_order() {
let mut manifest = manifest();
manifest.active_crons = vec![
cron("9f94c068", "6,26,46 * * * *", true),
cron("241252b6", "4,14,24,34,44,54 * * * *", true),
];
manifest.activate_scheduler(HOUR).unwrap();
assert_eq!(manifest.next_due(HOUR).unwrap().unwrap().id, "241252b6");
let due = manifest.claim_due(HOUR + 6 * 60).unwrap();
assert_eq!(due.len(), 2);
assert_eq!(due[0].id, "241252b6");
assert_eq!(due[1].id, "9f94c068");
assert!(due
.iter()
.all(|trigger| trigger.kind == ClaudeRuntimeTriggerKind::Cron));
for trigger in due {
manifest
.complete_delivery(trigger.kind, &trigger.id)
.unwrap();
}
assert_eq!(
manifest.next_due(HOUR + 6 * 60).unwrap().unwrap().due_unix,
HOUR + 14 * 60
);
}
#[test]
fn missed_recurring_ticks_claim_once_without_catchup_burst() {
let mut manifest = manifest();
manifest.active_crons = vec![cron("pilot", "6,26,46 * * * *", true)];
manifest.activate_scheduler(HOUR).unwrap();
let much_later = HOUR + 3 * 3_600;
let due = manifest.claim_due(much_later).unwrap();
assert_eq!(due.len(), 1);
manifest.complete_delivery(due[0].kind, &due[0].id).unwrap();
assert!(manifest.claim_due(much_later).unwrap().is_empty());
assert!(manifest.next_due(much_later).unwrap().unwrap().due_unix > much_later);
}
#[test]
fn overdue_wakeup_fires_once_and_is_removed() {
let mut manifest = manifest();
manifest.pending_wakeups.push(ClaudeWakeup {
tool_use_id: "wake-1".to_string(),
delay_seconds: 10,
reason: Some("check".to_string()),
prompt: None,
created_at: Some("2023-11-14T22:58:00.000Z".to_string()),
scheduled_for: Some("2023-11-14T22:58:10.000Z".to_string()),
creation_result: "scheduled".to_string(),
});
manifest.activate_scheduler(HOUR).unwrap();
let due = manifest.claim_due(HOUR).unwrap();
assert_eq!(due.len(), 1);
assert_eq!(due[0].kind, ClaudeRuntimeTriggerKind::Wakeup);
assert_eq!(due[0].prompt.as_deref(), Some("check"));
assert!(manifest.pending_wakeups.is_empty());
manifest.complete_delivery(due[0].kind, &due[0].id).unwrap();
assert!(manifest.claim_due(HOUR).unwrap().is_empty());
}
#[test]
fn pending_queue_claims_fifo_once_and_survives_disk_reload() {
let mut manifest = manifest();
manifest.queue = ClaudeQueueState {
enqueued: 5,
dequeued: 2,
removed: 0,
pending: vec!["first".into(), "duplicate".into(), "duplicate".into()],
};
assert!(manifest.next_due(HOUR).is_err(), "paused queues stay inert");
manifest.activate_scheduler(HOUR).unwrap();
assert_eq!(manifest.queue.pending.len(), 3);
assert_eq!(
manifest.next_due(HOUR).unwrap().unwrap().id,
"queue-00000000000000000002"
);
let claimed = manifest.claim_due(HOUR).unwrap();
assert_eq!(
claimed
.iter()
.map(|item| item.prompt.as_deref())
.collect::<Vec<_>>(),
vec![Some("first"), Some("duplicate"), Some("duplicate")]
);
assert_eq!(
claimed
.iter()
.map(|item| item.id.as_str())
.collect::<Vec<_>>(),
vec![
"queue-00000000000000000002",
"queue-00000000000000000003",
"queue-00000000000000000004",
]
);
assert!(claimed
.iter()
.all(|item| item.kind == ClaudeRuntimeTriggerKind::Queue));
assert!(manifest.queue.pending.is_empty());
let json = serde_json::to_string(&manifest).unwrap();
let mut reloaded: ClaudeRuntimeManifest = serde_json::from_str(&json).unwrap();
assert_eq!(reloaded.claim_due(HOUR).unwrap(), claimed);
for trigger in claimed {
reloaded
.complete_delivery(trigger.kind, &trigger.id)
.unwrap();
}
assert!(reloaded.claim_due(HOUR).unwrap().is_empty());
}
#[test]
fn inconsistent_queue_counters_fail_activation_without_mutation() {
let mut manifest = manifest();
manifest.queue.enqueued = 1;
manifest.queue.pending = vec!["one".into(), "two".into()];
let error = manifest.activate_scheduler(HOUR).unwrap_err().to_string();
assert!(
error.contains("2 pending prompts but only 1 enqueue"),
"{error}"
);
assert_eq!(manifest.queue.pending, vec!["one", "two"]);
assert_eq!(
manifest.execution_state,
ClaudeRuntimeExecutionState::Paused
);
}
#[test]
fn one_shot_is_removed_expiry_is_honored_and_state_reloads() {
let mut manifest = manifest();
manifest.active_crons.push(cron("once", "4 * * * *", false));
let mut expired = cron("expired", "5 * * * *", true);
expired.created_at = Some("2023-11-14T22:58:00.000Z".to_string());
expired.expires_after_seconds = Some(60);
manifest.active_crons.push(expired);
manifest.activate_scheduler(HOUR).unwrap();
assert_eq!(manifest.active_crons.len(), 1);
let json = serde_json::to_string(&manifest).unwrap();
let mut reloaded: ClaudeRuntimeManifest = serde_json::from_str(&json).unwrap();
assert_eq!(reloaded, manifest);
let due = reloaded.claim_due(HOUR + 4 * 60).unwrap();
assert_eq!(due.len(), 1);
assert!(reloaded.active_crons.is_empty());
let claimed_json = serde_json::to_string(&reloaded).unwrap();
let mut claimed_reload: ClaudeRuntimeManifest = serde_json::from_str(&claimed_json).unwrap();
assert_eq!(
claimed_reload.claim_due(HOUR + 4 * 60).unwrap(),
due,
"an unacknowledged delivery must survive disk reload"
);
claimed_reload
.complete_delivery(due[0].kind, &due[0].id)
.unwrap();
assert!(claimed_reload.claim_due(HOUR + 4 * 60).unwrap().is_empty());
}
#[test]
fn invalid_cron_fails_before_activation() {
let mut manifest = manifest();
manifest.active_crons.push(cron("bad", "*/0 * * * *", true));
let error = manifest.activate_scheduler(HOUR).unwrap_err().to_string();
assert!(error.contains("cron"), "{error}");
assert_eq!(
manifest.execution_state,
ClaudeRuntimeExecutionState::Paused
);
}