sage_codegen/

generator.rs

//! Main code generator.

use crate::emit::Emitter;
use sage_loader::ModuleTree;
use sage_parser::{
    AgentDecl, BinOp, Block, ConstDecl, EnumDecl, EventKind, Expr, FnDecl, InterpExpr, Literal,
    MockValue, Program, RecordDecl, Stmt, StringPart, TestDecl, TypeExpr, UnaryOp,
};

/// How to specify the sage-runtime dependency in generated Cargo.toml.
#[derive(Debug, Clone)]
pub enum RuntimeDep {
    /// Use the published crates.io version.
    CratesIo { version: String },
    /// Use a local path (for development).
    Path { path: String },
}

impl Default for RuntimeDep {
    fn default() -> Self {
        // Default to crates.io with the current version
        Self::CratesIo {
            version: env!("CARGO_PKG_VERSION").to_string(),
        }
    }
}

impl RuntimeDep {
    /// Generate the Cargo.toml dependency line.
    fn to_cargo_dep(&self) -> String {
        match self {
            RuntimeDep::CratesIo { version } => {
                format!("sage-runtime = \"{version}\"")
            }
            RuntimeDep::Path { path } => {
                format!("sage-runtime = {{ path = \"{path}\" }}")
            }
        }
    }
}

/// Generated Rust project files.
pub struct GeneratedProject {
    /// The main.rs content.
    pub main_rs: String,
    /// The Cargo.toml content.
    pub cargo_toml: String,
}

/// Generate Rust code from a Sage program (single file).
pub fn generate(program: &Program, project_name: &str) -> GeneratedProject {
    generate_with_config(program, project_name, RuntimeDep::default())
}

/// Generate Rust code from a Sage program with custom runtime dependency.
pub fn generate_with_config(
    program: &Program,
    project_name: &str,
    runtime_dep: RuntimeDep,
) -> GeneratedProject {
    let mut gen = Generator::new(runtime_dep);
    let main_rs = gen.generate_program(program);
    let cargo_toml = gen.generate_cargo_toml(project_name);
    GeneratedProject {
        main_rs,
        cargo_toml,
    }
}

/// Generate Rust code from a module tree (multi-file project).
///
/// This flattens all modules into a single Rust file, generating all agents
/// and functions with appropriate visibility modifiers.
pub fn generate_module_tree(tree: &ModuleTree, project_name: &str) -> GeneratedProject {
    generate_module_tree_with_config(tree, project_name, RuntimeDep::default())
}

/// Generate Rust code from a module tree with custom runtime dependency.
pub fn generate_module_tree_with_config(
    tree: &ModuleTree,
    project_name: &str,
    runtime_dep: RuntimeDep,
) -> GeneratedProject {
    let mut gen = Generator::new(runtime_dep);
    let main_rs = gen.generate_module_tree(tree);
    let cargo_toml = gen.generate_cargo_toml(project_name);
    GeneratedProject {
        main_rs,
        cargo_toml,
    }
}

/// Generated test project files (RFC-0012).
pub struct GeneratedTestProject {
    /// The test main.rs content.
    pub main_rs: String,
    /// The Cargo.toml content.
    pub cargo_toml: String,
}

/// Generate a test binary from a Sage test file (RFC-0012).
pub fn generate_test_program(program: &Program, test_name: &str) -> GeneratedTestProject {
    generate_test_program_with_config(program, test_name, RuntimeDep::default())
}

/// Generate a test binary with custom runtime dependency.
pub fn generate_test_program_with_config(
    program: &Program,
    test_name: &str,
    runtime_dep: RuntimeDep,
) -> GeneratedTestProject {
    let mut gen = Generator::new(runtime_dep);
    let main_rs = gen.generate_test_binary(program);
    let cargo_toml = gen.generate_test_cargo_toml(test_name);
    GeneratedTestProject {
        main_rs,
        cargo_toml,
    }
}

struct Generator {
    emit: Emitter,
    runtime_dep: RuntimeDep,
}

impl Generator {
    fn new(runtime_dep: RuntimeDep) -> Self {
        Self {
            emit: Emitter::new(),
            runtime_dep,
        }
    }

    fn generate_program(&mut self, program: &Program) -> String {
        // Prelude
        self.emit
            .writeln("//! Generated by Sage compiler. Do not edit.");
        self.emit.blank_line();
        self.emit.writeln("use sage_runtime::prelude::*;");
        self.emit.blank_line();

        // Constants
        for const_decl in &program.consts {
            self.generate_const(const_decl);
            self.emit.blank_line();
        }

        // Enums
        for enum_decl in &program.enums {
            self.generate_enum(enum_decl);
            self.emit.blank_line();
        }

        // Records
        for record in &program.records {
            self.generate_record(record);
            self.emit.blank_line();
        }

        // Functions
        for func in &program.functions {
            self.generate_function(func);
            self.emit.blank_line();
        }

        // Agents
        for agent in &program.agents {
            self.generate_agent(agent);
            self.emit.blank_line();
        }

        // Entry point (required for executables)
        if let Some(run_agent) = &program.run_agent {
            // Find the entry agent
            if let Some(agent) = program.agents.iter().find(|a| a.name.name == run_agent.name) {
                self.generate_main(agent);
            }
        }

        std::mem::take(&mut self.emit).finish()
    }

    fn generate_module_tree(&mut self, tree: &ModuleTree) -> String {
        // Prelude
        self.emit
            .writeln("//! Generated by Sage compiler. Do not edit.");
        self.emit.blank_line();
        self.emit.writeln("use sage_runtime::prelude::*;");
        self.emit.blank_line();

        // Generate all modules, starting with the root
        // We flatten everything into one file for simplicity
        // (A more advanced implementation would generate mod.rs files)

        // First, generate non-root modules
        for (path, module) in &tree.modules {
            if path != &tree.root {
                self.emit.write("// Module: ");
                if path.is_empty() {
                    self.emit.writeln("(root)");
                } else {
                    self.emit.writeln(&path.join("::"));
                }

                for const_decl in &module.program.consts {
                    self.generate_const(const_decl);
                    self.emit.blank_line();
                }

                for enum_decl in &module.program.enums {
                    self.generate_enum(enum_decl);
                    self.emit.blank_line();
                }

                for record in &module.program.records {
                    self.generate_record(record);
                    self.emit.blank_line();
                }

                for func in &module.program.functions {
                    self.generate_function(func);
                    self.emit.blank_line();
                }

                for agent in &module.program.agents {
                    self.generate_agent(agent);
                    self.emit.blank_line();
                }
            }
        }

        // Then, generate the root module
        if let Some(root_module) = tree.modules.get(&tree.root) {
            self.emit.writeln("// Root module");

            for const_decl in &root_module.program.consts {
                self.generate_const(const_decl);
                self.emit.blank_line();
            }

            for enum_decl in &root_module.program.enums {
                self.generate_enum(enum_decl);
                self.emit.blank_line();
            }

            for record in &root_module.program.records {
                self.generate_record(record);
                self.emit.blank_line();
            }

            for func in &root_module.program.functions {
                self.generate_function(func);
                self.emit.blank_line();
            }

            for agent in &root_module.program.agents {
                self.generate_agent(agent);
                self.emit.blank_line();
            }

            // Entry point (only in root module)
            if let Some(run_agent) = &root_module.program.run_agent {
                // Find the entry agent
                if let Some(agent) = root_module
                    .program
                    .agents
                    .iter()
                    .find(|a| a.name.name == run_agent.name)
                {
                    self.generate_main(agent);
                }
            }
        }

        std::mem::take(&mut self.emit).finish()
    }

    fn generate_cargo_toml(&self, name: &str) -> String {
        let runtime_dep = self.runtime_dep.to_cargo_dep();
        format!(
            r#"[package]
name = "{name}"
version = "0.1.0"
edition = "2021"

[dependencies]
{runtime_dep}
tokio = {{ version = "1", features = ["full"] }}
serde = {{ version = "1", features = ["derive"] }}
serde_json = "1"

# Standalone project, not part of parent workspace
[workspace]
"#
        )
    }

    // =========================================================================
    // RFC-0012: Test generation
    // =========================================================================

    fn generate_test_binary(&mut self, program: &Program) -> String {
        // Test prelude
        self.emit
            .writeln("//! Generated test file by Sage compiler. Do not edit.");
        self.emit.blank_line();
        self.emit.writeln("use sage_runtime::prelude::*;");
        self.emit.blank_line();

        // Constants (test files may import types/constants from main code)
        for const_decl in &program.consts {
            self.generate_const(const_decl);
            self.emit.blank_line();
        }

        // Enums
        for enum_decl in &program.enums {
            self.generate_enum(enum_decl);
            self.emit.blank_line();
        }

        // Records
        for record in &program.records {
            self.generate_record(record);
            self.emit.blank_line();
        }

        // Functions
        for func in &program.functions {
            self.generate_function(func);
            self.emit.blank_line();
        }

        // Agents (test files may define helper agents)
        for agent in &program.agents {
            self.generate_agent(agent);
            self.emit.blank_line();
        }

        // Separate serial and concurrent tests
        let (serial_tests, concurrent_tests): (Vec<_>, Vec<_>) =
            program.tests.iter().partition(|t| t.is_serial);

        // Generate concurrent test functions
        for test in &concurrent_tests {
            self.generate_test_function(test);
            self.emit.blank_line();
        }

        // Generate serial test functions (marked with #[serial])
        for test in &serial_tests {
            self.generate_test_function(test);
            self.emit.blank_line();
        }

        // Generate an empty main function (required for bin crates)
        self.emit.writeln("fn main() {}");

        std::mem::take(&mut self.emit).finish()
    }

    fn generate_test_cargo_toml(&self, name: &str) -> String {
        let runtime_dep = self.runtime_dep.to_cargo_dep();
        format!(
            r#"[package]
name = "{name}"
version = "0.1.0"
edition = "2021"

[dependencies]
{runtime_dep}
tokio = {{ version = "1", features = ["full"] }}
serde = {{ version = "1", features = ["derive"] }}
serde_json = "1"

# Standalone project, not part of parent workspace
[workspace]
"#
        )
    }

    fn generate_test_function(&mut self, test: &TestDecl) {
        // Collect mock infer statements from the test body
        let mocks = self.collect_mock_infers(&test.body);

        // Generate test function
        self.emit.writeln("#[tokio::test]");
        // Convert test name to valid Rust identifier
        let test_fn_name = self.sanitize_test_name(&test.name);
        self.emit.write("async fn ");
        self.emit.write(&test_fn_name);
        self.emit.writeln("() {");
        self.emit.indent();

        // Generate mock client if there are mocks
        if !mocks.is_empty() {
            self.emit.writeln("let _mock_client = MockLlmClient::with_responses(vec![");
            self.emit.indent();
            for mock in &mocks {
                match mock {
                    MockValue::Value(expr) => {
                        self.emit.write("MockResponse::value(");
                        self.generate_expr(expr);
                        self.emit.writeln("),");
                    }
                    MockValue::Fail(expr) => {
                        self.emit.write("MockResponse::fail(");
                        self.generate_expr(expr);
                        self.emit.writeln("),");
                    }
                }
            }
            self.emit.dedent();
            self.emit.writeln("]);");
            self.emit.blank_line();
        }

        // Generate test body (excluding mock infer statements)
        self.generate_test_block(&test.body);

        self.emit.dedent();
        self.emit.writeln("}");
    }

    fn collect_mock_infers(&self, block: &Block) -> Vec<MockValue> {
        let mut mocks = Vec::new();
        for stmt in &block.stmts {
            if let Stmt::MockInfer { value, .. } = stmt {
                mocks.push(value.clone());
            }
        }
        mocks
    }

    fn generate_test_block(&mut self, block: &Block) {
        for stmt in &block.stmts {
            // Skip mock infer statements - they were collected separately
            if matches!(stmt, Stmt::MockInfer { .. }) {
                continue;
            }
            self.generate_test_stmt(stmt);
        }
    }

    fn generate_test_stmt(&mut self, stmt: &Stmt) {
        match stmt {
            // Handle assertion builtins specially
            Stmt::Expr { expr, .. } => {
                if let Expr::Call { name, args, .. } = expr {
                    if self.is_assertion_builtin(&name.name) {
                        self.generate_assertion(&name.name, args);
                        return;
                    }
                }
                // Regular expression statement
                self.generate_expr(expr);
                self.emit.writeln(";");
            }
            // For other statements, use the normal generation
            _ => self.generate_stmt(stmt),
        }
    }

    fn is_assertion_builtin(&self, name: &str) -> bool {
        matches!(
            name,
            "assert"
                | "assert_eq"
                | "assert_neq"
                | "assert_gt"
                | "assert_lt"
                | "assert_gte"
                | "assert_lte"
                | "assert_true"
                | "assert_false"
                | "assert_contains"
                | "assert_not_contains"
                | "assert_empty"
                | "assert_not_empty"
                | "assert_starts_with"
                | "assert_ends_with"
                | "assert_len"
                | "assert_empty_list"
                | "assert_not_empty_list"
                | "assert_fails"
        )
    }

    fn generate_assertion(&mut self, name: &str, args: &[Expr]) {
        match name {
            "assert" | "assert_true" => {
                self.emit.write("assert!(");
                if !args.is_empty() {
                    self.generate_expr(&args[0]);
                }
                self.emit.writeln(");");
            }
            "assert_false" => {
                self.emit.write("assert!(!");
                if !args.is_empty() {
                    self.generate_expr(&args[0]);
                }
                self.emit.writeln(");");
            }
            "assert_eq" => {
                self.emit.write("assert_eq!(");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(", ");
                    self.generate_expr(&args[1]);
                }
                self.emit.writeln(");");
            }
            "assert_neq" => {
                self.emit.write("assert_ne!(");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(", ");
                    self.generate_expr(&args[1]);
                }
                self.emit.writeln(");");
            }
            "assert_gt" => {
                self.emit.write("assert!(");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(" > ");
                    self.generate_expr(&args[1]);
                }
                self.emit.writeln(");");
            }
            "assert_lt" => {
                self.emit.write("assert!(");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(" < ");
                    self.generate_expr(&args[1]);
                }
                self.emit.writeln(");");
            }
            "assert_gte" => {
                self.emit.write("assert!(");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(" >= ");
                    self.generate_expr(&args[1]);
                }
                self.emit.writeln(");");
            }
            "assert_lte" => {
                self.emit.write("assert!(");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(" <= ");
                    self.generate_expr(&args[1]);
                }
                self.emit.writeln(");");
            }
            "assert_contains" => {
                self.emit.write("assert!(");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(".contains(&");
                    self.generate_expr(&args[1]);
                    self.emit.write(")");
                }
                self.emit.writeln(");");
            }
            "assert_not_contains" => {
                self.emit.write("assert!(!");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(".contains(&");
                    self.generate_expr(&args[1]);
                    self.emit.write(")");
                }
                self.emit.writeln(");");
            }
            "assert_empty" => {
                self.emit.write("assert!(");
                if !args.is_empty() {
                    self.generate_expr(&args[0]);
                }
                self.emit.writeln(".is_empty());");
            }
            "assert_not_empty" => {
                self.emit.write("assert!(!");
                if !args.is_empty() {
                    self.generate_expr(&args[0]);
                }
                self.emit.writeln(".is_empty());");
            }
            "assert_starts_with" => {
                self.emit.write("assert!(");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(".starts_with(&");
                    self.generate_expr(&args[1]);
                    self.emit.write(")");
                }
                self.emit.writeln(");");
            }
            "assert_ends_with" => {
                self.emit.write("assert!(");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(".ends_with(&");
                    self.generate_expr(&args[1]);
                    self.emit.write(")");
                }
                self.emit.writeln(");");
            }
            "assert_len" => {
                self.emit.write("assert_eq!(");
                if args.len() >= 2 {
                    self.generate_expr(&args[0]);
                    self.emit.write(".len() as i64, ");
                    self.generate_expr(&args[1]);
                }
                self.emit.writeln(");");
            }
            "assert_empty_list" => {
                self.emit.write("assert!(");
                if !args.is_empty() {
                    self.generate_expr(&args[0]);
                }
                self.emit.writeln(".is_empty());");
            }
            "assert_not_empty_list" => {
                self.emit.write("assert!(!");
                if !args.is_empty() {
                    self.generate_expr(&args[0]);
                }
                self.emit.writeln(".is_empty());");
            }
            "assert_fails" => {
                // assert_fails expects an expression that should fail
                self.emit.writeln("{");
                self.emit.indent();
                self.emit.write("let result = ");
                if !args.is_empty() {
                    self.generate_expr(&args[0]);
                }
                self.emit.writeln(";");
                self.emit.writeln("assert!(result.is_err(), \"Expected operation to fail but it succeeded\");");
                self.emit.dedent();
                self.emit.writeln("}");
            }
            _ => {
                // Unknown assertion - just call it as a regular function
                self.emit.write(name);
                self.emit.write("(");
                for (i, arg) in args.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.generate_expr(arg);
                }
                self.emit.writeln(");");
            }
        }
    }

    fn sanitize_test_name(&self, name: &str) -> String {
        // Convert test name to valid Rust identifier
        name.chars()
            .map(|c| {
                if c.is_alphanumeric() {
                    c
                } else {
                    '_'
                }
            })
            .collect::<String>()
            .to_lowercase()
    }

    fn generate_const(&mut self, const_decl: &ConstDecl) {
        if const_decl.is_pub {
            self.emit.write("pub ");
        }
        self.emit.write("const ");
        self.emit.write(&const_decl.name.name);
        self.emit.write(": ");
        self.emit_type(&const_decl.ty);
        self.emit.write(" = ");
        self.generate_expr(&const_decl.value);
        self.emit.writeln(";");
    }

    fn generate_enum(&mut self, enum_decl: &EnumDecl) {
        if enum_decl.is_pub {
            self.emit.write("pub ");
        }
        self.emit
            .writeln("#[derive(Debug, Clone, Copy, PartialEq, Eq)]");
        self.emit.write("enum ");
        self.emit.write(&enum_decl.name.name);
        self.emit.writeln(" {");
        self.emit.indent();
        for variant in &enum_decl.variants {
            self.emit.write(&variant.name.name);
            if let Some(payload_ty) = &variant.payload {
                self.emit.write("(");
                self.emit_type(payload_ty);
                self.emit.write(")");
            }
            self.emit.writeln(",");
        }
        self.emit.dedent();
        self.emit.writeln("}");
    }

    fn generate_record(&mut self, record: &RecordDecl) {
        if record.is_pub {
            self.emit.write("pub ");
        }
        self.emit.writeln("#[derive(Debug, Clone)]");
        self.emit.write("struct ");
        self.emit.write(&record.name.name);
        self.emit.writeln(" {");
        self.emit.indent();
        for field in &record.fields {
            self.emit.write(&field.name.name);
            self.emit.write(": ");
            self.emit_type(&field.ty);
            self.emit.writeln(",");
        }
        self.emit.dedent();
        self.emit.writeln("}");
    }

    fn generate_function(&mut self, func: &FnDecl) {
        // Function signature with visibility
        if func.is_pub {
            self.emit.write("pub ");
        }
        self.emit.write("fn ");
        self.emit.write(&func.name.name);
        self.emit.write("(");

        for (i, param) in func.params.iter().enumerate() {
            if i > 0 {
                self.emit.write(", ");
            }
            self.emit.write(&param.name.name);
            self.emit.write(": ");
            self.emit_type(&param.ty);
        }

        self.emit.write(") -> ");

        // RFC-0007: Wrap return type in SageResult if fallible
        if func.is_fallible {
            self.emit.write("SageResult<");
            self.emit_type(&func.return_ty);
            self.emit.write(">");
        } else {
            self.emit_type(&func.return_ty);
        }

        self.emit.write(" ");
        self.generate_block(&func.body);
    }

    fn generate_agent(&mut self, agent: &AgentDecl) {
        let name = &agent.name.name;

        // RFC-0011: Check for tool usage
        let has_tools = !agent.tool_uses.is_empty();
        let needs_struct_body = !agent.beliefs.is_empty() || has_tools;

        // Struct definition with visibility
        if agent.is_pub {
            self.emit.write("pub ");
        }
        self.emit.write("struct ");
        self.emit.write(name);
        if !needs_struct_body {
            self.emit.writeln(";");
        } else {
            self.emit.writeln(" {");
            self.emit.indent();

            // RFC-0011: Generate tool fields
            for tool_use in &agent.tool_uses {
                // Generate field like: http: HttpClient
                self.emit.write(&tool_use.name.to_lowercase());
                self.emit.write(": ");
                self.emit.write(&tool_use.name);
                self.emit.writeln("Client,");
            }

            // Regular belief fields
            for belief in &agent.beliefs {
                self.emit.write(&belief.name.name);
                self.emit.write(": ");
                self.emit_type(&belief.ty);
                self.emit.writeln(",");
            }
            self.emit.dedent();
            self.emit.writeln("}");
        }
        self.emit.blank_line();

        // Find the output type from the start handler
        let output_type = self.infer_agent_output_type(agent);

        // Impl block
        self.emit.write("impl ");
        self.emit.write(name);
        self.emit.writeln(" {");
        self.emit.indent();

        // Generate handlers
        for handler in &agent.handlers {
            match &handler.event {
                EventKind::Start => {
                    self.emit
                        .write("async fn on_start(&self, ctx: &mut AgentContext<");
                    self.emit.write(&output_type);
                    self.emit.write(">) -> SageResult<");
                    self.emit.write(&output_type);
                    self.emit.writeln("> {");
                    self.emit.indent();
                    self.generate_block_contents(&handler.body);
                    self.emit.dedent();
                    self.emit.writeln("}");
                }

                // RFC-0007: Generate on_error handler
                EventKind::Error { param_name } => {
                    self.emit.write("async fn on_error(&self, ");
                    self.emit.write(&param_name.name);
                    self.emit.write(": SageError, ctx: &mut AgentContext<");
                    self.emit.write(&output_type);
                    self.emit.write(">) -> SageResult<");
                    self.emit.write(&output_type);
                    self.emit.writeln("> {");
                    self.emit.indent();
                    self.generate_block_contents(&handler.body);
                    self.emit.dedent();
                    self.emit.writeln("}");
                }

                // on stop handler - cleanup before termination
                EventKind::Stop => {
                    self.emit
                        .writeln("async fn on_stop(&self) {");
                    self.emit.indent();
                    self.generate_block_contents(&handler.body);
                    self.emit.dedent();
                    self.emit.writeln("}");
                }

                // Other handlers (message) - future work
                _ => {}
            }
        }

        self.emit.dedent();
        self.emit.writeln("}");
    }

    fn generate_main(&mut self, agent: &AgentDecl) {
        let entry_agent = &agent.name.name;
        let has_error_handler = agent
            .handlers
            .iter()
            .any(|h| matches!(h.event, EventKind::Error { .. }));

        let has_stop_handler = agent
            .handlers
            .iter()
            .any(|h| matches!(h.event, EventKind::Stop));

        // RFC-0011: Check if agent uses tools
        let has_tools = !agent.tool_uses.is_empty();

        self.emit.writeln("#[tokio::main]");
        self.emit
            .writeln("async fn main() -> Result<(), Box<dyn std::error::Error>> {");
        self.emit.indent();

        // Initialize tracing from environment variables
        self.emit.writeln("sage_runtime::trace::init();");
        self.emit.writeln("");

        // Helper to generate agent construction (with or without tool fields)
        let agent_construct = if has_tools {
            let mut s = format!("{entry_agent} {{ ");
            for (i, tool_use) in agent.tool_uses.iter().enumerate() {
                if i > 0 {
                    s.push_str(", ");
                }
                // Generate: http: HttpClient::from_env()
                s.push_str(&tool_use.name.to_lowercase());
                s.push_str(": ");
                s.push_str(&tool_use.name);
                s.push_str("Client::from_env()");
            }
            s.push_str(" }");
            s
        } else {
            entry_agent.to_string()
        };

        // Set up graceful shutdown signal handling
        self.emit
            .writeln("let ctrl_c = async { tokio::signal::ctrl_c().await.ok() };");

        self.emit.writeln("#[cfg(unix)]");
        self.emit.writeln("let terminate = async {");
        self.emit.indent();
        self.emit.writeln(
            "if let Ok(mut s) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) {",
        );
        self.emit.indent();
        self.emit.writeln("s.recv().await;");
        self.emit.dedent();
        self.emit.writeln("} else {");
        self.emit.indent();
        self.emit.writeln("std::future::pending::<()>().await;");
        self.emit.dedent();
        self.emit.writeln("}");
        self.emit.dedent();
        self.emit.writeln("};");
        self.emit.writeln("#[cfg(not(unix))]");
        self.emit.writeln("let terminate = std::future::pending::<()>();");
        self.emit.writeln("");

        self.emit
            .writeln("let handle = sage_runtime::spawn(|mut ctx| async move {");
        self.emit.indent();
        self.emit.write("let agent = ");
        self.emit.write(&agent_construct);
        self.emit.writeln(";");

        if has_error_handler {
            // RFC-0007: Generate error dispatch code
            self.emit
                .writeln("let result = match agent.on_start(&mut ctx).await {");
            self.emit.indent();
            self.emit.writeln("Ok(result) => Ok(result),");
            self.emit.writeln("Err(e) => agent.on_error(e, &mut ctx).await,");
            self.emit.dedent();
            self.emit.writeln("};");
        } else {
            // Simple case: no error handler
            self.emit
                .writeln("let result = agent.on_start(&mut ctx).await;");
        }

        if has_stop_handler {
            // Call on_stop for cleanup (errors are ignored)
            self.emit.writeln("agent.on_stop().await;");
        }

        self.emit.writeln("result");
        self.emit.dedent();
        self.emit.writeln("});");

        // Use tokio::select! to race between agent completion and shutdown signals
        self.emit.writeln("");
        self.emit.writeln("let result = tokio::select! {");
        self.emit.indent();
        self.emit.writeln("result = handle.result() => result?,");
        self.emit.writeln("_ = ctrl_c => {");
        self.emit.indent();
        self.emit.writeln("eprintln!(\"\\nReceived interrupt signal, shutting down...\");");
        self.emit.writeln("std::process::exit(0);");
        self.emit.dedent();
        self.emit.writeln("}");
        self.emit.writeln("_ = terminate => {");
        self.emit.indent();
        self.emit.writeln("eprintln!(\"Received terminate signal, shutting down...\");");
        self.emit.writeln("std::process::exit(0);");
        self.emit.dedent();
        self.emit.writeln("}");
        self.emit.dedent();
        self.emit.writeln("};");
        self.emit.writeln("println!(\"{:?}\", result);");
        self.emit.writeln("Ok(())");

        self.emit.dedent();
        self.emit.writeln("}");
    }

    fn generate_block(&mut self, block: &Block) {
        self.emit.open_brace();
        self.generate_block_contents(block);
        self.emit.close_brace();
    }

    fn generate_block_inline(&mut self, block: &Block) {
        self.emit.open_brace();
        self.generate_block_contents(block);
        self.emit.close_brace_inline();
    }

    fn generate_block_contents(&mut self, block: &Block) {
        for stmt in &block.stmts {
            self.generate_stmt(stmt);
        }
    }

    fn generate_stmt(&mut self, stmt: &Stmt) {
        match stmt {
            Stmt::Let {
                name, ty, value, ..
            } => {
                self.emit.write("let ");
                if ty.is_some() {
                    self.emit.write(&name.name);
                    self.emit.write(": ");
                    self.emit_type(ty.as_ref().unwrap());
                } else {
                    self.emit.write(&name.name);
                }
                self.emit.write(" = ");
                self.generate_expr(value);
                self.emit.writeln(";");
            }

            Stmt::Assign { name, value, .. } => {
                self.emit.write(&name.name);
                self.emit.write(" = ");
                self.generate_expr(value);
                self.emit.writeln(";");
            }

            Stmt::Return { value, .. } => {
                self.emit.write("return ");
                if let Some(expr) = value {
                    self.generate_expr(expr);
                }
                self.emit.writeln(";");
            }

            Stmt::If {
                condition,
                then_block,
                else_block,
                ..
            } => {
                self.emit.write("if ");
                self.generate_expr(condition);
                self.emit.write(" ");
                if else_block.is_some() {
                    self.generate_block_inline(then_block);
                    self.emit.write(" else ");
                    match else_block.as_ref().unwrap() {
                        sage_parser::ElseBranch::Block(block) => {
                            self.generate_block(block);
                        }
                        sage_parser::ElseBranch::ElseIf(stmt) => {
                            self.generate_stmt(stmt);
                        }
                    }
                } else {
                    self.generate_block(then_block);
                }
            }

            Stmt::For {
                pattern,
                iter,
                body,
                ..
            } => {
                self.emit.write("for ");
                self.emit_pattern(pattern);
                self.emit.write(" in ");
                self.generate_expr(iter);
                self.emit.write(" ");
                self.generate_block(body);
            }

            Stmt::While {
                condition, body, ..
            } => {
                self.emit.write("while ");
                self.generate_expr(condition);
                self.emit.write(" ");
                self.generate_block(body);
            }

            Stmt::Loop { body, .. } => {
                self.emit.write("loop ");
                self.generate_block(body);
            }

            Stmt::Break { .. } => {
                self.emit.writeln("break;");
            }

            Stmt::Expr { expr, .. } => {
                // Handle emit specially
                if let Expr::Emit { value, .. } = expr {
                    self.emit.write("return ctx.emit(");
                    self.generate_expr(value);
                    self.emit.writeln(");");
                } else {
                    self.generate_expr(expr);
                    self.emit.writeln(";");
                }
            }

            Stmt::LetTuple { names, value, .. } => {
                self.emit.write("let (");
                for (i, name) in names.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit.write(&name.name);
                }
                self.emit.write(") = ");
                self.generate_expr(value);
                self.emit.writeln(";");
            }

            // RFC-0012: mock infer - codegen will be handled in test harness generation
            Stmt::MockInfer { value, .. } => {
                // Mock statements are collected during test codegen, not emitted inline
                // This placeholder ensures the match is exhaustive
                self.emit.write("// mock infer: ");
                match value {
                    sage_parser::MockValue::Value(expr) => {
                        self.generate_expr(expr);
                    }
                    sage_parser::MockValue::Fail(expr) => {
                        self.emit.write("fail(");
                        self.generate_expr(expr);
                        self.emit.write(")");
                    }
                }
                self.emit.writeln(";");
            }
        }
    }

    fn generate_expr(&mut self, expr: &Expr) {
        match expr {
            Expr::Literal { value, .. } => {
                self.emit_literal(value);
            }

            Expr::Var { name, .. } => {
                // Handle builtin constants (RFC-0013)
                match name.name.as_str() {
                    "PI" => self.emit.write("std::f64::consts::PI"),
                    "E" => self.emit.write("std::f64::consts::E"),
                    _ => self.emit.write(&name.name),
                }
            }

            Expr::Binary {
                op, left, right, ..
            } => {
                // Handle string concatenation specially
                if matches!(op, BinOp::Concat) {
                    self.emit.write("format!(\"{}{}\", ");
                    self.generate_expr(left);
                    self.emit.write(", ");
                    self.generate_expr(right);
                    self.emit.write(")");
                } else {
                    self.emit.write("(");
                    self.generate_expr(left);
                    self.emit.write(" ");
                    self.emit_binop(op);
                    self.emit.write(" ");
                    self.generate_expr(right);
                    self.emit.write(")");
                }
            }

            Expr::Unary { op, operand, .. } => {
                self.emit_unaryop(op);
                self.generate_expr(operand);
            }

            Expr::Call { name, args, .. } => {
                let fn_name = &name.name;

                // Handle builtins
                match fn_name.as_str() {
                    "print" => {
                        self.emit.write("println!(\"{}\", ");
                        self.generate_expr(&args[0]);
                        self.emit.write(")");
                    }
                    "str" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".to_string()");
                    }
                    "len" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".len() as i64");
                    }

                    // RFC-0013: String functions
                    "split" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".split(&*");
                        self.generate_expr(&args[1]);
                        self.emit.write(").map(str::to_string).collect::<Vec<_>>()");
                    }
                    "trim" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".trim().to_string()");
                    }
                    "trim_start" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".trim_start().to_string()");
                    }
                    "trim_end" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".trim_end().to_string()");
                    }
                    "starts_with" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".starts_with(&*");
                        self.generate_expr(&args[1]);
                        self.emit.write(")");
                    }
                    "ends_with" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".ends_with(&*");
                        self.generate_expr(&args[1]);
                        self.emit.write(")");
                    }
                    "replace" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".replace(&*");
                        self.generate_expr(&args[1]);
                        self.emit.write(", &*");
                        self.generate_expr(&args[2]);
                        self.emit.write(")");
                    }
                    "replace_first" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".replacen(&*");
                        self.generate_expr(&args[1]);
                        self.emit.write(", &*");
                        self.generate_expr(&args[2]);
                        self.emit.write(", 1)");
                    }
                    "to_upper" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".to_uppercase()");
                    }
                    "to_lower" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".to_lowercase()");
                    }
                    "str_len" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".chars().count() as i64");
                    }
                    "str_slice" => {
                        self.emit.write("sage_runtime::stdlib::str_slice(&");
                        self.generate_expr(&args[0]);
                        self.emit.write(", ");
                        self.generate_expr(&args[1]);
                        self.emit.write(", ");
                        self.generate_expr(&args[2]);
                        self.emit.write(")");
                    }
                    "str_index_of" => {
                        self.emit.write("sage_runtime::stdlib::str_index_of(&");
                        self.generate_expr(&args[0]);
                        self.emit.write(", &");
                        self.generate_expr(&args[1]);
                        self.emit.write(")");
                    }
                    "str_repeat" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".repeat(");
                        self.generate_expr(&args[1]);
                        self.emit.write(" as usize)");
                    }
                    "str_pad_start" => {
                        self.emit.write("sage_runtime::stdlib::str_pad_start(&");
                        self.generate_expr(&args[0]);
                        self.emit.write(", ");
                        self.generate_expr(&args[1]);
                        self.emit.write(", &");
                        self.generate_expr(&args[2]);
                        self.emit.write(")");
                    }
                    "str_pad_end" => {
                        self.emit.write("sage_runtime::stdlib::str_pad_end(&");
                        self.generate_expr(&args[0]);
                        self.emit.write(", ");
                        self.generate_expr(&args[1]);
                        self.emit.write(", &");
                        self.generate_expr(&args[2]);
                        self.emit.write(")");
                    }

                    // RFC-0013: Math functions
                    "abs" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".abs()");
                    }
                    "abs_float" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".abs()");
                    }
                    "min" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".min(");
                        self.generate_expr(&args[1]);
                        self.emit.write(")");
                    }
                    "max" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".max(");
                        self.generate_expr(&args[1]);
                        self.emit.write(")");
                    }
                    "min_float" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".min(");
                        self.generate_expr(&args[1]);
                        self.emit.write(")");
                    }
                    "max_float" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".max(");
                        self.generate_expr(&args[1]);
                        self.emit.write(")");
                    }
                    "clamp" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".clamp(");
                        self.generate_expr(&args[1]);
                        self.emit.write(", ");
                        self.generate_expr(&args[2]);
                        self.emit.write(")");
                    }
                    "clamp_float" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".clamp(");
                        self.generate_expr(&args[1]);
                        self.emit.write(", ");
                        self.generate_expr(&args[2]);
                        self.emit.write(")");
                    }
                    "floor" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".floor() as i64");
                    }
                    "ceil" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".ceil() as i64");
                    }
                    "round" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".round() as i64");
                    }
                    "floor_float" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".floor()");
                    }
                    "ceil_float" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".ceil()");
                    }
                    "pow" => {
                        // Safe power: handle negative exponents by returning 0
                        self.emit.write("{ let __base = ");
                        self.generate_expr(&args[0]);
                        self.emit.write("; let __exp = ");
                        self.generate_expr(&args[1]);
                        self.emit.write("; if __exp < 0 { 0 } else { __base.pow(__exp as u32) } }");
                    }
                    "pow_float" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".powf(");
                        self.generate_expr(&args[1]);
                        self.emit.write(")");
                    }
                    "sqrt" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".sqrt()");
                    }
                    "int_to_float" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(" as f64");
                    }
                    "float_to_int" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(" as i64");
                    }

                    // RFC-0013: Parsing functions
                    "parse_int" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".trim().parse::<i64>().map_err(|e| e.to_string())");
                    }
                    "parse_float" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".trim().parse::<f64>().map_err(|e| e.to_string())");
                    }
                    "parse_bool" => {
                        self.emit.write("sage_runtime::stdlib::parse_bool(&");
                        self.generate_expr(&args[0]);
                        self.emit.write(")");
                    }
                    "float_to_str" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".to_string()");
                    }
                    "bool_to_str" => {
                        self.emit.write("if ");
                        self.generate_expr(&args[0]);
                        self.emit.write(" { \"true\".to_string() } else { \"false\".to_string() }");
                    }

                    // RFC-0013: List Higher-Order Functions
                    "map" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().map(");
                        self.generate_expr(&args[1]);
                        self.emit.write(").collect::<Vec<_>>()");
                    }
                    "filter" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().filter(|__x| (");
                        self.generate_expr(&args[1]);
                        self.emit.write(")((__x).clone())).collect::<Vec<_>>()");
                    }
                    "reduce" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().fold(");
                        self.generate_expr(&args[1]);
                        self.emit.write(", ");
                        self.generate_expr(&args[2]);
                        self.emit.write(")");
                    }
                    "any" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().any(|__x| (");
                        self.generate_expr(&args[1]);
                        self.emit.write(")((__x).clone()))");
                    }
                    "all" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().all(|__x| (");
                        self.generate_expr(&args[1]);
                        self.emit.write(")((__x).clone()))");
                    }
                    "find" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().find(|__x| (");
                        self.generate_expr(&args[1]);
                        self.emit.write(")((__x).clone()))");
                    }
                    "flat_map" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().flat_map(");
                        self.generate_expr(&args[1]);
                        self.emit.write(").collect::<Vec<_>>()");
                    }
                    "zip" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().zip(");
                        self.generate_expr(&args[1]);
                        self.emit.write(".into_iter()).collect::<Vec<_>>()");
                    }
                    "sort_by" => {
                        self.emit.write("{ let mut __v = ");
                        self.generate_expr(&args[0]);
                        self.emit.write("; __v.sort_by(|__a, __b| { let __cmp = (");
                        self.generate_expr(&args[1]);
                        self.emit.write(")((__a).clone(), (__b).clone()); if __cmp < 0 { std::cmp::Ordering::Less } else if __cmp > 0 { std::cmp::Ordering::Greater } else { std::cmp::Ordering::Equal } }); __v }");
                    }
                    "enumerate" => {
                        self.generate_expr(&args[0]);
                        self.emit
                            .write(".into_iter().enumerate().map(|(__i, __x)| (__i as i64, __x)).collect::<Vec<_>>()");
                    }
                    "take" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().take(");
                        self.generate_expr(&args[1]);
                        self.emit.write(" as usize).collect::<Vec<_>>()");
                    }
                    "drop" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().skip(");
                        self.generate_expr(&args[1]);
                        self.emit.write(" as usize).collect::<Vec<_>>()");
                    }
                    "flatten" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().flatten().collect::<Vec<_>>()");
                    }
                    "reverse" => {
                        self.emit.write("{ let mut __v = ");
                        self.generate_expr(&args[0]);
                        self.emit.write("; __v.reverse(); __v }");
                    }
                    "unique" => {
                        self.emit.write("{ let mut __seen = std::collections::HashSet::new(); ");
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().filter(|__x| __seen.insert(format!(\"{:?}\", __x))).collect::<Vec<_>>() }");
                    }
                    "count_where" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".into_iter().filter(|__x| (");
                        self.generate_expr(&args[1]);
                        self.emit.write(")((__x).clone())).count() as i64");
                    }
                    "sum" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".iter().sum::<i64>()");
                    }
                    "sum_floats" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".iter().sum::<f64>()");
                    }

                    _ => {
                        self.emit.write(fn_name);
                        self.emit.write("(");
                        for (i, arg) in args.iter().enumerate() {
                            if i > 0 {
                                self.emit.write(", ");
                            }
                            self.generate_expr(arg);
                        }
                        self.emit.write(")");
                    }
                }
            }

            Expr::SelfField { field, .. } => {
                self.emit.write("self.");
                self.emit.write(&field.name);
            }

            Expr::SelfMethodCall { method, args, .. } => {
                self.emit.write("self.");
                self.emit.write(&method.name);
                self.emit.write("(");
                for (i, arg) in args.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.generate_expr(arg);
                }
                self.emit.write(")");
            }

            Expr::List { elements, .. } => {
                self.emit.write("vec![");
                for (i, elem) in elements.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.generate_expr(elem);
                }
                self.emit.write("]");
            }

            Expr::Paren { inner, .. } => {
                self.emit.write("(");
                self.generate_expr(inner);
                self.emit.write(")");
            }

            Expr::Infer { template, .. } => {
                self.emit.write("ctx.infer_string(&");
                self.emit_string_template(template);
                self.emit.write(").await?");
            }

            Expr::Spawn { agent, fields, .. } => {
                self.emit.write("sage_runtime::spawn(|ctx| ");
                self.emit.write(&agent.name);
                if fields.is_empty() {
                    self.emit.write(".on_start(ctx))");
                } else {
                    self.emit.write(" { ");
                    for (i, field) in fields.iter().enumerate() {
                        if i > 0 {
                            self.emit.write(", ");
                        }
                        self.emit.write(&field.name.name);
                        self.emit.write(": ");
                        self.generate_expr(&field.value);
                    }
                    self.emit.write(" }.on_start(ctx))");
                }
            }

            Expr::Await {
                handle, timeout, ..
            } => {
                if let Some(timeout_expr) = timeout {
                    // With timeout: wrap in tokio::time::timeout
                    self.emit.write("tokio::time::timeout(");
                    self.emit.write("std::time::Duration::from_millis(");
                    self.generate_expr(timeout_expr);
                    self.emit.write(" as u64), ");
                    self.generate_expr(handle);
                    self.emit
                        .write(".result()).await.map_err(|_| sage_runtime::SageError::agent(");
                    self.emit.write("\"await timed out\"))??");
                } else {
                    // Without timeout: simple await
                    self.generate_expr(handle);
                    self.emit.write(".result().await?");
                }
            }

            Expr::Send {
                handle, message, ..
            } => {
                self.generate_expr(handle);
                self.emit.write(".send(sage_runtime::Message::new(");
                self.generate_expr(message);
                self.emit.write(")?).await?");
            }

            Expr::Emit { value, .. } => {
                self.emit.write("ctx.emit(");
                self.generate_expr(value);
                self.emit.write(")");
            }

            Expr::StringInterp { template, .. } => {
                self.emit_string_template(template);
            }

            Expr::Match {
                scrutinee, arms, ..
            } => {
                self.emit.write("match ");
                self.generate_expr(scrutinee);
                self.emit.writeln(" {");
                self.emit.indent();
                for arm in arms {
                    self.emit_pattern(&arm.pattern);
                    self.emit.write(" => ");
                    self.generate_expr(&arm.body);
                    self.emit.writeln(",");
                }
                self.emit.dedent();
                self.emit.write("}");
            }

            Expr::RecordConstruct { name, fields, .. } => {
                self.emit.write(&name.name);
                self.emit.write(" { ");
                for (i, field) in fields.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit.write(&field.name.name);
                    self.emit.write(": ");
                    self.generate_expr(&field.value);
                }
                self.emit.write(" }");
            }

            Expr::FieldAccess { object, field, .. } => {
                self.generate_expr(object);
                self.emit.write(".");
                self.emit.write(&field.name);
            }

            Expr::Receive { .. } => {
                self.emit.write("ctx.receive().await?");
            }

            // RFC-0007: Error handling
            Expr::Try { expr, .. } => {
                // Generate the inner expression with ? for error propagation
                self.generate_expr(expr);
                self.emit.write("?");
            }

            Expr::Catch {
                expr,
                error_bind,
                recovery,
                ..
            } => {
                // Generate a match expression to handle the Result
                self.emit.write("match ");
                self.generate_expr(expr);
                self.emit.writeln(" {");
                self.emit.indent();

                // Ok arm - unwrap the value
                self.emit.writeln("Ok(__val) => __val,");

                // Err arm - run recovery
                if let Some(err_name) = error_bind {
                    self.emit.write("Err(");
                    self.emit.write(&err_name.name);
                    self.emit.write(") => ");
                } else {
                    self.emit.write("Err(_) => ");
                }
                self.generate_expr(recovery);
                self.emit.writeln(",");

                self.emit.dedent();
                self.emit.write("}");
            }

            // fail expression - explicit error raising
            Expr::Fail { error, .. } => {
                // Generate: return Err(SageError::agent(msg))
                // TODO: Use SageError::user once runtime 0.6.1 is published
                self.emit.write("return Err(sage_runtime::SageError::agent(");
                self.generate_expr(error);
                self.emit.write("))");
            }

            // retry expression - retry a fallible operation
            Expr::Retry {
                count,
                delay,
                on_errors: _,
                body,
                ..
            } => {
                // Generate a retry loop with async block
                self.emit.writeln("'_retry: {");
                self.emit.indent();

                self.emit.write("let _retry_max: i64 = ");
                self.generate_expr(count);
                self.emit.writeln(";");

                if let Some(delay_expr) = delay {
                    self.emit.write("let _retry_delay: u64 = ");
                    self.generate_expr(delay_expr);
                    self.emit.writeln(" as u64;");
                }

                self.emit
                    .writeln("let mut _last_error: Option<sage_runtime::SageError> = None;");
                self.emit.writeln("for _attempt in 0.._retry_max {");
                self.emit.indent();

                // Wrap body in async block that returns Result
                self.emit.writeln("let _result = (async {");
                self.emit.indent();
                self.emit.write("Ok::<_, sage_runtime::SageError>(");
                self.generate_expr(body);
                self.emit.writeln(")");
                self.emit.dedent();
                self.emit.writeln("}).await;");

                self.emit.writeln("match _result {");
                self.emit.indent();
                self.emit.writeln("Ok(v) => break '_retry v,");
                self.emit.writeln("Err(e) => {");
                self.emit.indent();
                self.emit.writeln("_last_error = Some(e);");

                // Add delay between retries if specified
                if delay.is_some() {
                    self.emit.writeln("if _attempt < _retry_max - 1 {");
                    self.emit.indent();
                    self.emit.writeln(
                        "tokio::time::sleep(std::time::Duration::from_millis(_retry_delay)).await;",
                    );
                    self.emit.dedent();
                    self.emit.writeln("}");
                }

                self.emit.dedent();
                self.emit.writeln("}");
                self.emit.dedent();
                self.emit.writeln("}");

                self.emit.dedent();
                self.emit.writeln("}");

                // After loop exhausted, return the last error
                self.emit.writeln("return Err(_last_error.unwrap());");

                self.emit.dedent();
                self.emit.write("}");
            }

            // trace(message) - emit a trace event
            Expr::Trace { message, .. } => {
                self.emit.write("sage_runtime::trace::user(&");
                self.generate_expr(message);
                self.emit.write(")");
            }

            // RFC-0009: Closures
            Expr::Closure { params, body, .. } => {
                // Generate: Box::new(move |param1: Type1, param2: Type2| { body })
                self.emit.write("Box::new(move |");
                for (i, param) in params.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit.write(&param.name.name);
                    if let Some(ty) = &param.ty {
                        self.emit.write(": ");
                        self.emit_type(ty);
                    }
                }
                self.emit.write("| ");
                self.generate_expr(body);
                self.emit.write(")");
            }

            // RFC-0010: Tuples and Maps
            Expr::Tuple { elements, .. } => {
                self.emit.write("(");
                for (i, elem) in elements.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.generate_expr(elem);
                }
                self.emit.write(")");
            }

            Expr::TupleIndex { tuple, index, .. } => {
                self.generate_expr(tuple);
                self.emit.write(&format!(".{index}"));
            }

            Expr::Map { entries, .. } => {
                if entries.is_empty() {
                    self.emit.write("std::collections::HashMap::new()");
                } else {
                    self.emit.write("std::collections::HashMap::from([");
                    for (i, entry) in entries.iter().enumerate() {
                        if i > 0 {
                            self.emit.write(", ");
                        }
                        self.emit.write("(");
                        self.generate_expr(&entry.key);
                        self.emit.write(", ");
                        self.generate_expr(&entry.value);
                        self.emit.write(")");
                    }
                    self.emit.write("])");
                }
            }

            Expr::VariantConstruct {
                enum_name,
                variant,
                payload,
                ..
            } => {
                self.emit.write(&enum_name.name);
                self.emit.write("::");
                self.emit.write(&variant.name);
                if let Some(payload_expr) = payload {
                    self.emit.write("(");
                    self.generate_expr(payload_expr);
                    self.emit.write(")");
                }
            }

            // RFC-0011: Tool calls
            Expr::ToolCall {
                tool,
                function,
                args,
                ..
            } => {
                // Generate: self.tool_name.function(args).await
                // Returns SageResult<T> - must be handled with try/catch
                self.emit.write("self.");
                self.emit.write(&tool.name.to_lowercase());
                self.emit.write(".");
                self.emit.write(&function.name);
                self.emit.write("(");
                for (i, arg) in args.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.generate_expr(arg);
                }
                self.emit.write(").await");
            }
        }
    }

    fn emit_pattern(&mut self, pattern: &sage_parser::Pattern) {
        use sage_parser::Pattern;
        match pattern {
            Pattern::Wildcard { .. } => {
                self.emit.write("_");
            }
            Pattern::Variant {
                enum_name,
                variant,
                payload,
                ..
            } => {
                if let Some(enum_name) = enum_name {
                    self.emit.write(&enum_name.name);
                    self.emit.write("::");
                }
                self.emit.write(&variant.name);
                if let Some(inner_pattern) = payload {
                    self.emit.write("(");
                    self.emit_pattern(inner_pattern);
                    self.emit.write(")");
                }
            }
            Pattern::Literal { value, .. } => {
                self.emit_literal(value);
            }
            Pattern::Binding { name, .. } => {
                self.emit.write(&name.name);
            }
            Pattern::Tuple { elements, .. } => {
                self.emit.write("(");
                for (i, elem) in elements.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit_pattern(elem);
                }
                self.emit.write(")");
            }
        }
    }

    fn emit_literal(&mut self, lit: &Literal) {
        match lit {
            Literal::Int(n) => {
                self.emit.write(&format!("{n}_i64"));
            }
            Literal::Float(f) => {
                self.emit.write(&format!("{f}_f64"));
            }
            Literal::Bool(b) => {
                self.emit.write(if *b { "true" } else { "false" });
            }
            Literal::String(s) => {
                // Escape the string for Rust
                self.emit.write("\"");
                for c in s.chars() {
                    match c {
                        '"' => self.emit.write_raw("\\\""),
                        '\\' => self.emit.write_raw("\\\\"),
                        '\n' => self.emit.write_raw("\\n"),
                        '\r' => self.emit.write_raw("\\r"),
                        '\t' => self.emit.write_raw("\\t"),
                        _ => self.emit.write_raw(&c.to_string()),
                    }
                }
                self.emit.write("\".to_string()");
            }
        }
    }

    fn emit_string_template(&mut self, template: &sage_parser::StringTemplate) {
        if !template.has_interpolations() {
            // Simple string literal
            if let Some(StringPart::Literal(s)) = template.parts.first() {
                self.emit.write("\"");
                self.emit.write_raw(s);
                self.emit.write("\".to_string()");
            }
            return;
        }

        // Build format string and args
        self.emit.write("format!(\"");
        for part in &template.parts {
            match part {
                StringPart::Literal(s) => {
                    // Escape braces for format string
                    let escaped = s.replace('{', "{{").replace('}', "}}");
                    self.emit.write_raw(&escaped);
                }
                StringPart::Interpolation(_) => {
                    self.emit.write_raw("{}");
                }
            }
        }
        self.emit.write("\"");

        // Add the interpolation args
        for part in &template.parts {
            if let StringPart::Interpolation(interp_expr) = part {
                self.emit.write(", ");
                self.emit_interp_expr(interp_expr);
            }
        }
        self.emit.write(")");
    }

    /// Emit code for an interpolation expression (RFC-0013).
    fn emit_interp_expr(&mut self, expr: &InterpExpr) {
        match expr {
            InterpExpr::Ident(ident) => {
                self.emit.write(&ident.name);
            }
            InterpExpr::FieldAccess { base, field, .. } => {
                self.emit_interp_expr(base);
                self.emit.write(".");
                self.emit.write(&field.name);
            }
            InterpExpr::TupleIndex { base, index, .. } => {
                self.emit_interp_expr(base);
                self.emit.write(".");
                self.emit.write(&index.to_string());
            }
        }
    }

    fn emit_type(&mut self, ty: &TypeExpr) {
        match ty {
            TypeExpr::Int => self.emit.write("i64"),
            TypeExpr::Float => self.emit.write("f64"),
            TypeExpr::Bool => self.emit.write("bool"),
            TypeExpr::String => self.emit.write("String"),
            TypeExpr::Unit => self.emit.write("()"),
            TypeExpr::List(inner) => {
                self.emit.write("Vec<");
                self.emit_type(inner);
                self.emit.write(">");
            }
            TypeExpr::Option(inner) => {
                self.emit.write("Option<");
                self.emit_type(inner);
                self.emit.write(">");
            }
            TypeExpr::Inferred(inner) => {
                // Inferred<T> just becomes T at runtime
                self.emit_type(inner);
            }
            TypeExpr::Agent(agent_name) => {
                // Agent handles use the agent's output type, but we don't know it here
                // For now, just use a generic output type
                self.emit.write("AgentHandle<");
                self.emit.write(&agent_name.name);
                self.emit.write("Output>");
            }
            TypeExpr::Named(name) => {
                self.emit.write(&name.name);
            }

            // RFC-0007: Error handling
            TypeExpr::Error => {
                self.emit.write("sage_runtime::SageError");
            }

            // RFC-0009: Function types
            TypeExpr::Fn(params, ret) => {
                self.emit.write("Box<dyn Fn(");
                for (i, param) in params.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit_type(param);
                }
                self.emit.write(") -> ");
                self.emit_type(ret);
                self.emit.write(" + Send + 'static>");
            }

            // RFC-0010: Maps, tuples, Result
            TypeExpr::Map(key, value) => {
                self.emit.write("std::collections::HashMap<");
                self.emit_type(key);
                self.emit.write(", ");
                self.emit_type(value);
                self.emit.write(">");
            }
            TypeExpr::Tuple(elems) => {
                self.emit.write("(");
                for (i, elem) in elems.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit_type(elem);
                }
                self.emit.write(")");
            }
            TypeExpr::Result(ok, err) => {
                self.emit.write("Result<");
                self.emit_type(ok);
                self.emit.write(", ");
                self.emit_type(err);
                self.emit.write(">");
            }
        }
    }

    fn emit_binop(&mut self, op: &BinOp) {
        let s = match op {
            BinOp::Add => "+",
            BinOp::Sub => "-",
            BinOp::Mul => "*",
            BinOp::Div => "/",
            BinOp::Rem => "%",
            BinOp::Eq => "==",
            BinOp::Ne => "!=",
            BinOp::Lt => "<",
            BinOp::Gt => ">",
            BinOp::Le => "<=",
            BinOp::Ge => ">=",
            BinOp::And => "&&",
            BinOp::Or => "||",
            BinOp::Concat => "++", // Handled specially above
        };
        self.emit.write(s);
    }

    fn emit_unaryop(&mut self, op: &UnaryOp) {
        let s = match op {
            UnaryOp::Neg => "-",
            UnaryOp::Not => "!",
        };
        self.emit.write(s);
    }

    fn infer_agent_output_type(&self, agent: &AgentDecl) -> String {
        // Look for emit expression in start handler to infer return type
        // For now, default to i64
        for handler in &agent.handlers {
            if let EventKind::Start = &handler.event {
                if let Some(ty) = self.find_emit_type(&handler.body) {
                    return ty;
                }
            }
        }
        "i64".to_string()
    }

    fn find_emit_type(&self, block: &Block) -> Option<String> {
        for stmt in &block.stmts {
            if let Stmt::Expr { expr, .. } = stmt {
                if let Expr::Emit { value, .. } = expr {
                    return Some(self.infer_expr_type(value));
                }
            }
            // Check nested blocks
            if let Stmt::If {
                then_block,
                else_block,
                ..
            } = stmt
            {
                if let Some(ty) = self.find_emit_type(then_block) {
                    return Some(ty);
                }
                if let Some(else_branch) = else_block {
                    if let sage_parser::ElseBranch::Block(block) = else_branch {
                        if let Some(ty) = self.find_emit_type(block) {
                            return Some(ty);
                        }
                    }
                }
            }
        }
        None
    }

    fn infer_expr_type(&self, expr: &Expr) -> String {
        match expr {
            Expr::Literal { value, .. } => match value {
                Literal::Int(_) => "i64".to_string(),
                Literal::Float(_) => "f64".to_string(),
                Literal::Bool(_) => "bool".to_string(),
                Literal::String(_) => "String".to_string(),
            },
            Expr::Var { .. } => "i64".to_string(), // Conservative default
            Expr::Binary { op, .. } => {
                if matches!(
                    op,
                    BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Gt | BinOp::Le | BinOp::Ge
                ) {
                    "bool".to_string()
                } else if matches!(op, BinOp::Concat) {
                    "String".to_string()
                } else {
                    "i64".to_string()
                }
            }
            Expr::Infer { .. } | Expr::StringInterp { .. } => "String".to_string(),
            Expr::Call { name, .. } if name.name == "str" => "String".to_string(),
            Expr::Call { name, .. } if name.name == "len" => "i64".to_string(),
            _ => "i64".to_string(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use sage_parser::{lex, parse};
    use std::sync::Arc;

    fn generate_source(source: &str) -> String {
        let lex_result = lex(source).expect("lexing failed");
        let source_arc: Arc<str> = Arc::from(source);
        let (program, errors) = parse(lex_result.tokens(), source_arc);
        assert!(errors.is_empty(), "parse errors: {errors:?}");
        let program = program.expect("should parse");
        generate(&program, "test").main_rs
    }

    #[test]
    fn generate_minimal_program() {
        let source = r#"
            agent Main {
                on start {
                    emit(42);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("struct Main;"));
        assert!(output.contains("async fn on_start"));
        assert!(output.contains("ctx.emit(42_i64)"));
        assert!(output.contains("#[tokio::main]"));
    }

    #[test]
    fn generate_function() {
        let source = r#"
            fn add(a: Int, b: Int) -> Int {
                return a + b;
            }
            agent Main {
                on start {
                    emit(add(1, 2));
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("fn add(a: i64, b: i64) -> i64"));
        assert!(output.contains("return (a + b);"));
    }

    #[test]
    fn generate_agent_with_beliefs() {
        let source = r#"
            agent Worker {
                value: Int

                on start {
                    emit(self.value * 2);
                }
            }
            agent Main {
                on start {
                    emit(0);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("struct Worker {"));
        assert!(output.contains("value: i64,"));
        assert!(output.contains("self.value"));
    }

    #[test]
    fn generate_string_interpolation() {
        let source = r#"
            agent Main {
                on start {
                    let name = "World";
                    let msg = "Hello, {name}!";
                    print(msg);
                    emit(0);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("format!(\"Hello, {}!\", name)"));
    }

    #[test]
    fn generate_control_flow() {
        let source = r#"
            agent Main {
                on start {
                    let x = 10;
                    if x > 5 {
                        emit(1);
                    } else {
                        emit(0);
                    }
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("if (x > 5_i64)"), "output:\n{output}");
        // else is on the same line after close brace
        assert!(output.contains("else"), "output:\n{output}");
    }

    #[test]
    fn generate_loops() {
        let source = r#"
            agent Main {
                on start {
                    for x in [1, 2, 3] {
                        print(str(x));
                    }
                    let n = 0;
                    while n < 5 {
                        n = n + 1;
                    }
                    emit(n);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("for x in vec![1_i64, 2_i64, 3_i64]"));
        assert!(output.contains("while (n < 5_i64)"));
    }

    #[test]
    fn generate_pub_function() {
        let source = r#"
            pub fn helper(x: Int) -> Int {
                return x * 2;
            }
            agent Main {
                on start {
                    emit(helper(21));
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("pub fn helper(x: i64) -> i64"));
    }

    #[test]
    fn generate_pub_agent() {
        let source = r#"
            pub agent Worker {
                on start {
                    emit(42);
                }
            }
            agent Main {
                on start {
                    emit(0);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("pub struct Worker;"));
    }

    #[test]
    fn generate_module_tree_simple() {
        use sage_loader::load_single_file;
        use std::fs;
        use tempfile::TempDir;

        let dir = TempDir::new().unwrap();
        let file = dir.path().join("test.sg");
        fs::write(
            &file,
            r#"
agent Main {
    on start {
        emit(42);
    }
}
run Main;
"#,
        )
        .unwrap();

        let tree = load_single_file(&file).unwrap();
        let project = generate_module_tree(&tree, "test");

        assert!(project.main_rs.contains("struct Main;"));
        assert!(project.main_rs.contains("async fn on_start"));
        assert!(project.main_rs.contains("#[tokio::main]"));
    }

    #[test]
    fn generate_record_declaration() {
        let source = r#"
            record Point {
                x: Int,
                y: Int,
            }
            agent Main {
                on start {
                    let p = Point { x: 10, y: 20 };
                    emit(p.x);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("#[derive(Debug, Clone)]"));
        assert!(output.contains("struct Point {"));
        assert!(output.contains("x: i64,"));
        assert!(output.contains("y: i64,"));
        assert!(output.contains("Point { x: 10_i64, y: 20_i64 }"));
        assert!(output.contains("p.x"));
    }

    #[test]
    fn generate_enum_declaration() {
        let source = r#"
            enum Status {
                Active,
                Inactive,
                Pending,
            }
            agent Main {
                on start {
                    emit(0);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("#[derive(Debug, Clone, Copy, PartialEq, Eq)]"));
        assert!(output.contains("enum Status {"));
        assert!(output.contains("Active,"));
        assert!(output.contains("Inactive,"));
        assert!(output.contains("Pending,"));
    }

    #[test]
    fn generate_const_declaration() {
        let source = r#"
            const MAX_SIZE: Int = 100;
            const GREETING: String = "Hello";
            agent Main {
                on start {
                    emit(MAX_SIZE);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("const MAX_SIZE: i64 = 100_i64;"));
        assert!(output.contains("const GREETING: String = \"Hello\".to_string();"));
    }

    #[test]
    fn generate_match_expression() {
        let source = r#"
            enum Status {
                Active,
                Inactive,
            }
            fn check_status(s: Status) -> Int {
                return match s {
                    Active => 1,
                    Inactive => 0,
                };
            }
            agent Main {
                on start {
                    emit(0);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("match s {"));
        assert!(output.contains("Active => 1_i64,"));
        assert!(output.contains("Inactive => 0_i64,"));
    }

    // =========================================================================
    // RFC-0007: Error handling codegen tests
    // =========================================================================

    #[test]
    fn generate_fallible_function() {
        let source = r#"
            fn get_data(url: String) -> String fails {
                return url;
            }
            agent Main {
                on start { emit(0); }
            }
            run Main;
        "#;

        let output = generate_source(source);
        // Fallible function should return SageResult<T>
        assert!(output.contains("fn get_data(url: String) -> SageResult<String>"));
    }

    #[test]
    fn generate_try_expression() {
        let source = r#"
            fn fallible() -> Int fails { return 42; }
            fn caller() -> Int fails {
                let x = try fallible();
                return x;
            }
            agent Main {
                on start { emit(0); }
            }
            run Main;
        "#;

        let output = generate_source(source);
        // try should generate ? operator
        assert!(output.contains("fallible()?"));
    }

    #[test]
    fn generate_catch_expression() {
        let source = r#"
            fn fallible() -> Int fails { return 42; }
            agent Main {
                on start {
                    let x = fallible() catch { 0 };
                    emit(x);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        // catch should generate match expression
        assert!(output.contains("match fallible()"));
        assert!(output.contains("Ok(__val) => __val"));
        assert!(output.contains("Err(_) => 0_i64"));
    }

    #[test]
    fn generate_catch_with_binding() {
        let source = r#"
            fn fallible() -> Int fails { return 42; }
            agent Main {
                on start {
                    let x = fallible() catch(e) { 0 };
                    emit(x);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        // catch with binding should capture the error
        assert!(output.contains("Err(e) => 0_i64"));
    }

    #[test]
    fn generate_on_error_handler() {
        let source = r#"
            agent Main {
                on start {
                    emit(0);
                }
                on error(e) {
                    emit(1);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        // Should generate on_error method with &self and &mut ctx
        assert!(output.contains("async fn on_error(&self, e: SageError, ctx: &mut AgentContext"));
        // Main should dispatch to on_error on failure with &mut ctx
        assert!(output.contains(".on_error(e, &mut ctx)"));
    }

    // =========================================================================
    // RFC-0011: Tool support codegen tests
    // =========================================================================

    #[test]
    fn generate_agent_with_tool_use() {
        let source = r#"
            agent Fetcher {
                use Http

                on start {
                    let r = Http.get("https://example.com");
                    emit(0);
                }
            }
            run Fetcher;
        "#;

        let output = generate_source(source);
        // Should generate struct with http field
        assert!(output.contains("struct Fetcher {"));
        assert!(output.contains("http: HttpClient,"));
        // Should initialize HttpClient in main
        assert!(output.contains("http: HttpClient::from_env()"));
        // Should generate tool call
        assert!(output.contains("self.http.get("));
    }

    #[test]
    fn generate_tool_call_expression() {
        let source = r#"
            agent Fetcher {
                use Http

                on start {
                    let response = Http.get("https://httpbin.org/get");
                    emit(0);
                }
            }
            run Fetcher;
        "#;

        let output = generate_source(source);
        // Tool call should generate self.http.get(...).await (no ?, handled by try/catch)
        assert!(output.contains("self.http.get(\"https://httpbin.org/get\".to_string()).await"));
    }
}