supercode-core 0.2.1

//! Claude runtime compatibility tools edit paused or active scheduler state;
//! timer execution remains outside the agent. Every provider here is an
//! in-memory deterministic script.

use std::sync::atomic::{AtomicUsize, Ordering};

use async_trait::async_trait;
use supercode::{
    Agent, ChatMessage, ChatRequest, ClaudeRuntimeExecutionState, ClaudeRuntimeManifest, Config,
    FunctionCall, Provider, Role, ToolCall, Usage,
};

fn imported_manifest() -> ClaudeRuntimeManifest {
    serde_json::from_value(serde_json::json!({
        "schema_version": 1,
        "execution_state": "paused",
        "posture": {
            "permission_mode": null,
            "last_prompt_leaf_uuid": null,
            "last_prompt": null,
            "timestamp": null,
            "entrypoint": "cli",
            "user_type": "external",
            "version": "2.1.197",
            "cwd": "/tmp/fleet"
        },
        "active_crons": [
            {
                "id": "old-a",
                "tool_use_id": "import-a",
                "schedule": "6,26,46 * * * *",
                "recurring": true,
                "durable_requested": true,
                "prompt": "DO_NOT_EXECUTE_CRON_A",
                "created_at": "2026-07-14T10:00:00Z",
                "expires_after_seconds": null,
                "creation_result": "Scheduled recurring job old-a (6,26,46 * * * *)."
            },
            {
                "id": "old-b",
                "tool_use_id": "import-b",
                "schedule": "4,14,24,34,44,54 * * * *",
                "recurring": true,
                "durable_requested": false,
                "prompt": "DO_NOT_EXECUTE_CRON_B",
                "created_at": "2026-07-14T10:01:00Z",
                "expires_after_seconds": null,
                "creation_result": "Scheduled recurring job old-b (4,14,24,34,44,54 * * * *)."
            }
        ],
        "pending_wakeups": [],
        "queue": {"enqueued": 0, "dequeued": 0, "removed": 0, "pending": []},
        "background_children": [],
        "reported_pending_background_children": 0,
        "residue": []
    }))
    .unwrap()
}

fn active_manifest() -> ClaudeRuntimeManifest {
    let mut manifest = imported_manifest();
    let now_unix = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_secs() as i64;
    manifest.activate_scheduler(now_unix).unwrap();
    manifest
}

fn call(id: &str, name: &str, arguments: serde_json::Value) -> ChatMessage {
    ChatMessage {
        role: Role::Assistant,
        content: None,
        content_parts: None,
        tool_calls: Some(vec![ToolCall {
            id: id.to_string(),
            kind: "function".to_string(),
            function: FunctionCall {
                name: name.to_string(),
                arguments: arguments.to_string(),
            },
        }]),
        tool_call_id: None,
        name: None,
        metadata: Default::default(),
    }
}

struct ClaudeBuiltinAliasScript(AtomicUsize);

#[async_trait]
impl Provider for ClaudeBuiltinAliasScript {
    async fn complete(
        &self,
        req: &ChatRequest,
        _on_delta: &(dyn for<'a> Fn(&'a str) + Send + Sync),
    ) -> supercode::Result<(ChatMessage, Usage)> {
        for name in ["Bash", "Read", "Write", "Edit", "Glob", "Grep"] {
            assert!(req.tools.iter().any(|schema| schema.name == name));
        }
        let message = match self.0.fetch_add(1, Ordering::SeqCst) {
            0 => call(
                "claude-bash",
                "Bash",
                serde_json::json!({"command": "printf alias-ok", "timeout": 5000}),
            ),
            1 => {
                let result = req.messages.last().unwrap();
                assert_eq!(result.role, Role::Tool);
                assert_eq!(result.name.as_deref(), Some("Bash"));
                assert!(result.content.as_deref().unwrap().contains("alias-ok"));
                ChatMessage::assistant("alias executed")
            }
            other => panic!("unexpected provider turn {other}"),
        };
        Ok((message, Usage::default()))
    }
}

#[tokio::test]
async fn imported_claude_builtin_names_are_advertised_and_execute_natively() {
    let config = Config::builder()
        .claude_runtime_tools_enabled(true)
        .max_iterations(3)
        .build();
    let mut agent = Agent::with_provider(
        config,
        Box::new(ClaudeBuiltinAliasScript(AtomicUsize::new(0))),
    );
    assert_eq!(agent.send("continue").await.unwrap(), "alias executed");
}

struct PausedRuntimeScript {
    turn: AtomicUsize,
    injected_runtime_prompts: AtomicUsize,
}

#[async_trait]
impl Provider for PausedRuntimeScript {
    async fn complete(
        &self,
        req: &ChatRequest,
        _on_delta: &(dyn for<'a> Fn(&'a str) + Send + Sync),
    ) -> supercode::Result<(ChatMessage, Usage)> {
        for message in &req.messages {
            if message.role == Role::User
                && message.content.as_deref().is_some_and(|text| {
                    text.starts_with("DO_NOT_EXECUTE_CRON")
                        || text.starts_with("DO_NOT_EXECUTE_WAKEUP")
                })
            {
                self.injected_runtime_prompts.fetch_add(1, Ordering::SeqCst);
            }
        }

        let names: Vec<&str> = req
            .tools
            .iter()
            .map(|schema| schema.name.as_str())
            .collect();
        for expected in ["CronCreate", "CronDelete", "CronList", "ScheduleWakeup"] {
            assert!(names.contains(&expected), "missing schema {expected}");
        }

        let turn = self.turn.fetch_add(1, Ordering::SeqCst);
        let message = match turn {
            0 => call("list", "CronList", serde_json::json!({})),
            1 => {
                let result: serde_json::Value =
                    serde_json::from_str(req.messages.last().unwrap().content.as_deref().unwrap())
                        .unwrap();
                assert_eq!(result["execution_state"], "paused");
                assert_eq!(result["jobs"].as_array().unwrap().len(), 2);
                call(
                    "create",
                    "CronCreate",
                    serde_json::json!({
                        "cron": "*/5 * * * *",
                        "prompt": "DO_NOT_EXECUTE_CRON_NEW",
                        "recurring": true,
                        "durable": true
                    }),
                )
            }
            2 => {
                let result = req.messages.last().unwrap().content.as_deref().unwrap();
                assert!(result.contains("PAUSED"));
                assert!(result.contains("will not execute"));
                call("delete", "CronDelete", serde_json::json!({"id": "old-a"}))
            }
            3 => call(
                "wake-one",
                "ScheduleWakeup",
                serde_json::json!({
                    "delaySeconds": 30,
                    "reason": "first",
                    "prompt": "DO_NOT_EXECUTE_WAKEUP_ONE"
                }),
            ),
            4 => {
                let result = req.messages.last().unwrap().content.as_deref().unwrap();
                assert!(result.contains("PAUSED"));
                assert!(result.contains("no timer is running"));
                call(
                    "wake-two",
                    "ScheduleWakeup",
                    serde_json::json!({
                        "delaySeconds": 90,
                        "reason": "replacement",
                        "prompt": "DO_NOT_EXECUTE_WAKEUP_TWO"
                    }),
                )
            }
            5 => ChatMessage::assistant("paused runtime state updated"),
            other => panic!("unexpected provider turn {other}"),
        };
        Ok((message, Usage::default()))
    }
}

#[tokio::test]
async fn imported_crons_mutate_and_wakeup_replaces_without_execution() {
    let provider = PausedRuntimeScript {
        turn: AtomicUsize::new(0),
        injected_runtime_prompts: AtomicUsize::new(0),
    };
    let config = Config::builder()
        .claude_runtime_tools_enabled(true)
        .max_iterations(8)
        .build();
    let mut agent = Agent::with_provider(config, Box::new(provider));
    agent.set_claude_runtime_manifest(imported_manifest());

    let reply = agent.send("continue safely").await.unwrap();
    assert_eq!(reply, "paused runtime state updated");

    let manifest = agent.claude_runtime_manifest().unwrap();
    assert_eq!(
        manifest.execution_state,
        ClaudeRuntimeExecutionState::Paused
    );
    let ids: Vec<&str> = manifest
        .active_crons
        .iter()
        .map(|job| job.id.as_str())
        .collect();
    assert_eq!(ids, ["old-b", "sc000001"]);
    assert_eq!(manifest.pending_wakeups.len(), 1);
    assert_eq!(manifest.pending_wakeups[0].tool_use_id, "wake-two");
    assert_eq!(manifest.pending_wakeups[0].delay_seconds, 90);
    assert_eq!(
        manifest.pending_wakeups[0].prompt.as_deref(),
        Some("DO_NOT_EXECUTE_WAKEUP_TWO")
    );

    // Runtime prompts only ever occurred inside assistant tool arguments;
    // none was injected as an executable user turn.
    assert!(!agent.history().iter().any(|message| {
        message.role == Role::User
            && message.content.as_deref().is_some_and(|text| {
                text.starts_with("DO_NOT_EXECUTE_CRON") || text.starts_with("DO_NOT_EXECUTE_WAKEUP")
            })
    }));
}

struct ActiveRuntimeScript {
    turn: AtomicUsize,
}

#[async_trait]
impl Provider for ActiveRuntimeScript {
    async fn complete(
        &self,
        req: &ChatRequest,
        _on_delta: &(dyn for<'a> Fn(&'a str) + Send + Sync),
    ) -> supercode::Result<(ChatMessage, Usage)> {
        let turn = self.turn.fetch_add(1, Ordering::SeqCst);
        let message = match turn {
            0 => call("active-list", "CronList", serde_json::json!({})),
            1 => {
                let result: serde_json::Value =
                    serde_json::from_str(req.messages.last().unwrap().content.as_deref().unwrap())
                        .unwrap();
                assert_eq!(result["execution_state"], "active");
                assert!(result["execution_notice"]
                    .as_str()
                    .unwrap()
                    .contains("attached scheduler"));
                assert!(result["jobs"]
                    .as_array()
                    .unwrap()
                    .iter()
                    .all(|job| job["state"] == "active"));
                call(
                    "active-create",
                    "CronCreate",
                    serde_json::json!({
                        "cron": "*/5 * * * *",
                        "prompt": "ACTIVE_CRON",
                        "recurring": true,
                        "durable": true
                    }),
                )
            }
            2 => {
                let result = req.messages.last().unwrap().content.as_deref().unwrap();
                assert!(result.contains("ACTIVE"));
                assert!(result.contains("attached scheduler"));
                call(
                    "active-delete",
                    "CronDelete",
                    serde_json::json!({"id": "old-a"}),
                )
            }
            3 => {
                let result = req.messages.last().unwrap().content.as_deref().unwrap();
                assert!(result.contains("ACTIVE scheduler state"));
                call(
                    "active-wakeup",
                    "ScheduleWakeup",
                    serde_json::json!({
                        "delaySeconds": 90,
                        "reason": "active replacement",
                        "prompt": "ACTIVE_WAKEUP"
                    }),
                )
            }
            4 => {
                let result = req.messages.last().unwrap().content.as_deref().unwrap();
                assert!(result.contains("Runtime state is ACTIVE"));
                assert!(!result.contains("scheduled for PAUSED"));
                ChatMessage::assistant("active runtime state updated")
            }
            other => panic!("unexpected provider turn {other}"),
        };
        Ok((message, Usage::default()))
    }
}

#[tokio::test]
async fn active_runtime_mutations_are_scheduler_ready() {
    let before_unix = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_secs() as i64;
    let config = Config::builder()
        .claude_runtime_tools_enabled(true)
        .max_iterations(8)
        .build();
    let mut agent = Agent::with_provider(
        config,
        Box::new(ActiveRuntimeScript {
            turn: AtomicUsize::new(0),
        }),
    );
    agent.set_claude_runtime_manifest(active_manifest());

    assert_eq!(
        agent.send("continue actively").await.unwrap(),
        "active runtime state updated"
    );
    let after_unix = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_secs() as i64;

    let manifest = agent.claude_runtime_manifest().unwrap();
    assert_eq!(
        manifest.execution_state,
        ClaudeRuntimeExecutionState::Active
    );
    assert!(!manifest.active_crons.iter().any(|job| job.id == "old-a"));
    let created = manifest
        .active_crons
        .iter()
        .find(|job| job.id == "sc000001")
        .unwrap();
    assert!(created
        .created_at
        .as_deref()
        .is_some_and(|ts| ts.ends_with('Z')));
    let wakeup = manifest.pending_wakeups.first().unwrap();
    assert_eq!(wakeup.tool_use_id, "active-wakeup");
    assert!(wakeup
        .created_at
        .as_deref()
        .is_some_and(|ts| ts.ends_with('Z')));
    assert!(wakeup
        .scheduled_for
        .as_deref()
        .is_some_and(|ts| ts.ends_with('Z')));

    assert!(manifest
        .scheduler
        .activated_at_unix
        .is_some_and(|at| at <= after_unix));
    assert!(manifest
        .scheduler
        .cron_jobs
        .iter()
        .any(|job| job.id == "sc000001" && job.next_due_unix >= before_unix));
    assert!(!manifest
        .scheduler
        .cron_jobs
        .iter()
        .any(|job| job.id == "old-a"));
    assert_eq!(manifest.scheduler.wakeups.len(), 1);
    let scheduled = &manifest.scheduler.wakeups[0];
    assert_eq!(scheduled.tool_use_id, "active-wakeup");
    assert!(scheduled.due_unix >= before_unix + 89);
    assert!(scheduled.due_unix <= after_unix + 91);
}

#[test]
fn compatibility_surface_is_default_off() {
    let agent = Agent::with_provider(Config::default(), Box::new(NeverCalled));
    let names: Vec<String> = agent
        .tool_schemas()
        .into_iter()
        .map(|schema| schema.name)
        .collect();
    for absent in ["CronCreate", "CronDelete", "CronList", "ScheduleWakeup"] {
        assert!(!names.iter().any(|name| name == absent));
    }
}

struct NeverCalled;

#[async_trait]
impl Provider for NeverCalled {
    async fn complete(
        &self,
        _req: &ChatRequest,
        _on_delta: &(dyn for<'a> Fn(&'a str) + Send + Sync),
    ) -> supercode::Result<(ChatMessage, Usage)> {
        panic!("provider must not be called")
    }
}