diff --git a/src/cli.rs b/src/cli.rs
index 558c9b2..f57dc09 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -541,7 +541,7 @@ pub enum DiffCommands {
     /// Compare two programs
     Programs(DiffProgramsArgs),
     /// Compare functions
-    Functions(QueryOptions),
+    Functions(DiffFunctionsArgs),
 }
 
 #[derive(Args, Clone, Serialize, Deserialize, Debug)]
@@ -552,6 +552,16 @@ pub struct DiffProgramsArgs {
     pub format: Option<String>,
 }
 
+#[derive(Args, Clone, Serialize, Deserialize, Debug)]
+pub struct DiffFunctionsArgs {
+    /// First function (name or address)
+    pub func1: String,
+    /// Second function (name or address)
+    pub func2: String,
+    #[arg(long)]
+    pub format: Option<String>,
+}
+
 #[derive(Subcommand, Clone, Serialize, Deserialize, Debug)]
 pub enum DumpCommands {
     /// Dump imports
diff --git a/src/daemon/handler.rs b/src/daemon/handler.rs
index ffb1476..21fd4af 100644
--- a/src/daemon/handler.rs
+++ b/src/daemon/handler.rs
@@ -96,6 +96,19 @@ async fn handle_command_inner(
                 "address": address,
             }))).await
         }
+
+        Command::ExecuteCli { command_json } => {
+            // Deserialize and execute CLI command through the queue handlers
+            let cli_command: crate::cli::Commands = serde_json::from_str(&command_json)
+                .map_err(|e| anyhow::anyhow!("Failed to deserialize CLI command: {}", e))?;
+
+            // Execute using the queue's command execution logic
+            let result = crate::daemon::queue::execute_command_direct(bridge, &cli_command).await?;
+
+            // Parse the result as JSON (handlers return JSON strings)
+            Ok(serde_json::from_str(&result)
+                .unwrap_or_else(|_| json!({"output": result})))
+        }
     }
 }
 
diff --git a/src/daemon/handlers/batch.rs b/src/daemon/handlers/batch.rs
new file mode 100644
index 0000000..8be11fc
--- /dev/null
+++ b/src/daemon/handlers/batch.rs
@@ -0,0 +1,55 @@
+//! Batch operation handler.
+
+use anyhow::{Context, Result};
+use std::fs;
+use std::path::Path;
+use serde_json::json;
+
+pub async fn handle_batch(file_path: &str) -> Result<String> {
+    let path = Path::new(file_path);
+
+    if !path.exists() {
+        anyhow::bail!("Batch file not found: {}", file_path);
+    }
+
+    let content = fs::read_to_string(path)
+        .with_context(|| format!("Failed to read batch file: {}", file_path))?;
+
+    let mut results = Vec::new();
+    let mut line_number = 0;
+
+    for line in content.lines() {
+        line_number += 1;
+        let trimmed = line.trim();
+
+        if trimmed.is_empty() || trimmed.starts_with('#') {
+            continue;
+        }
+
+        results.push(json!({
+            "line": line_number,
+            "command": trimmed,
+            "status": "not_implemented",
+            "message": "Batch command execution not yet implemented"
+        }));
+    }
+
+    let response = json!({
+        "file": file_path,
+        "commands_parsed": results.len(),
+        "results": results
+    });
+
+    serde_json::to_string_pretty(&response)
+        .context("Failed to serialize batch results")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_batch_placeholder() {
+        assert!(true);
+    }
+}
diff --git a/src/daemon/handlers/comments.rs b/src/daemon/handlers/comments.rs
new file mode 100644
index 0000000..97f67b2
--- /dev/null
+++ b/src/daemon/handlers/comments.rs
@@ -0,0 +1,90 @@
+//! Comment operation handlers.
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_comment_list(bridge: &mut GhidraBridge) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "comment_list",
+        None
+    ).context("Failed to list comments")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to list comments".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_comment_get(
+    bridge: &mut GhidraBridge,
+    address: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "comment_get",
+        Some(json!({"address": address}))
+    ).context("Failed to get comment")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to get comment".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_comment_set(
+    bridge: &mut GhidraBridge,
+    address: &str,
+    text: &str,
+    comment_type: Option<&str>
+) -> Result<String> {
+    let mut args = json!({
+        "address": address,
+        "text": text
+    });
+
+    if let Some(ctype) = comment_type {
+        args["comment_type"] = json!(ctype);
+    }
+
+    let response = bridge.send_command::<serde_json::Value>(
+        "comment_set",
+        Some(args)
+    ).context("Failed to set comment")?;
+
+    if response.status == "success" {
+        Ok(json!({"status": "set", "address": address}).to_string())
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to set comment".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_comment_delete(
+    bridge: &mut GhidraBridge,
+    address: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "comment_delete",
+        Some(json!({"address": address}))
+    ).context("Failed to delete comment")?;
+
+    if response.status == "success" {
+        Ok(json!({"status": "deleted", "address": address}).to_string())
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to delete comment".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+}
diff --git a/src/daemon/handlers/diff.rs b/src/daemon/handlers/diff.rs
new file mode 100644
index 0000000..2067121
--- /dev/null
+++ b/src/daemon/handlers/diff.rs
@@ -0,0 +1,55 @@
+//! Diff operation handlers.
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_diff_programs(
+    bridge: &mut GhidraBridge,
+    prog1: &str,
+    prog2: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "diff_programs",
+        Some(json!({"prog1": prog1, "prog2": prog2}))
+    ).context("Failed to diff programs")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to diff programs".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_diff_functions(
+    bridge: &mut GhidraBridge,
+    func1: &str,
+    func2: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "diff_functions",
+        Some(json!({"func1": func1, "func2": func2}))
+    ).context("Failed to diff functions")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to diff functions".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_diff_handlers_exist() {
+        assert!(true);
+    }
+}
diff --git a/src/daemon/handlers/disasm.rs b/src/daemon/handlers/disasm.rs
new file mode 100644
index 0000000..69e6297
--- /dev/null
+++ b/src/daemon/handlers/disasm.rs
@@ -0,0 +1,41 @@
+//! Disassembly operation handler.
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_disasm(
+    bridge: &mut GhidraBridge,
+    address: &str,
+    count: Option<usize>
+) -> Result<String> {
+    let mut args = json!({"address": address});
+
+    if let Some(num) = count {
+        args["count"] = json!(num);
+    }
+
+    let response = bridge.send_command::<serde_json::Value>(
+        "disasm",
+        Some(args)
+    ).context("Failed to disassemble")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to disassemble".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_disasm_placeholder() {
+        assert!(true);
+    }
+}
diff --git a/src/daemon/handlers/find.rs b/src/daemon/handlers/find.rs
new file mode 100644
index 0000000..374b9cf
--- /dev/null
+++ b/src/daemon/handlers/find.rs
@@ -0,0 +1,123 @@
+//! Find/search operation handlers.
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_find_string(
+    bridge: &mut GhidraBridge,
+    pattern: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "find_string",
+        Some(json!({"pattern": pattern}))
+    ).context("Failed to find string")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to find string".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_find_bytes(
+    bridge: &mut GhidraBridge,
+    hex: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "find_bytes",
+        Some(json!({"hex": hex}))
+    ).context("Failed to find bytes")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to find bytes".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_find_function(
+    bridge: &mut GhidraBridge,
+    pattern: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "find_function",
+        Some(json!({"pattern": pattern}))
+    ).context("Failed to find function")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to find function".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_find_calls(
+    bridge: &mut GhidraBridge,
+    function: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "find_calls",
+        Some(json!({"function": function}))
+    ).context("Failed to find calls")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to find calls".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_find_crypto(bridge: &mut GhidraBridge) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "find_crypto",
+        None
+    ).context("Failed to find crypto constants")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to find crypto constants".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_find_interesting(bridge: &mut GhidraBridge) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "find_interesting",
+        None
+    ).context("Failed to find interesting functions")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to find interesting functions".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_find_placeholder() {
+        assert!(true);
+    }
+}
diff --git a/src/daemon/handlers/graph.rs b/src/daemon/handlers/graph.rs
new file mode 100644
index 0000000..9ab3ba2
--- /dev/null
+++ b/src/daemon/handlers/graph.rs
@@ -0,0 +1,104 @@
+//! Graph operation handlers.
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_graph_calls(
+    bridge: &mut GhidraBridge,
+    limit: Option<usize>
+) -> Result<String> {
+    let args = if let Some(lim) = limit {
+        Some(json!({"limit": lim}))
+    } else {
+        None
+    };
+
+    let response = bridge.send_command::<serde_json::Value>(
+        "graph_calls",
+        args
+    ).context("Failed to get call graph")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to get call graph".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_graph_callers(
+    bridge: &mut GhidraBridge,
+    function: &str,
+    depth: Option<usize>
+) -> Result<String> {
+    let mut args = json!({"function": function});
+    if let Some(d) = depth {
+        args["depth"] = json!(d);
+    }
+
+    let response = bridge.send_command::<serde_json::Value>(
+        "graph_callers",
+        Some(args)
+    ).context("Failed to get callers")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to get callers".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_graph_callees(
+    bridge: &mut GhidraBridge,
+    function: &str,
+    depth: Option<usize>
+) -> Result<String> {
+    let mut args = json!({"function": function});
+    if let Some(d) = depth {
+        args["depth"] = json!(d);
+    }
+
+    let response = bridge.send_command::<serde_json::Value>(
+        "graph_callees",
+        Some(args)
+    ).context("Failed to get callees")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to get callees".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_graph_export(
+    bridge: &mut GhidraBridge,
+    format: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "graph_export",
+        Some(json!({"format": format}))
+    ).context("Failed to export graph")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to export graph".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+}
diff --git a/src/daemon/handlers/mod.rs b/src/daemon/handlers/mod.rs
new file mode 100644
index 0000000..02594ad
--- /dev/null
+++ b/src/daemon/handlers/mod.rs
@@ -0,0 +1,14 @@
+//! Handler modules for daemon commands grouped by category.
+
+pub mod program;
+pub mod symbols;
+pub mod types;
+pub mod comments;
+pub mod graph;
+pub mod find;
+pub mod diff;
+pub mod patch;
+pub mod script;
+pub mod disasm;
+pub mod batch;
+pub mod stats;
diff --git a/src/daemon/handlers/patch.rs b/src/daemon/handlers/patch.rs
new file mode 100644
index 0000000..3edb207
--- /dev/null
+++ b/src/daemon/handlers/patch.rs
@@ -0,0 +1,76 @@
+//! Patch operation handlers.
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_patch_bytes(
+    bridge: &mut GhidraBridge,
+    address: &str,
+    hex: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "patch_bytes",
+        Some(json!({
+            "address": address,
+            "hex": hex
+        }))
+    ).context("Failed to patch bytes")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to patch bytes".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_patch_nop(
+    bridge: &mut GhidraBridge,
+    address: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "patch_nop",
+        Some(json!({"address": address}))
+    ).context("Failed to patch NOP")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to patch NOP".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_patch_export(
+    bridge: &mut GhidraBridge,
+    output: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "patch_export",
+        Some(json!({"output": output}))
+    ).context("Failed to export patched binary")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to export patched binary".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_placeholder() {
+        assert!(true);
+    }
+}
diff --git a/src/daemon/handlers/program.rs b/src/daemon/handlers/program.rs
new file mode 100644
index 0000000..4790a91
--- /dev/null
+++ b/src/daemon/handlers/program.rs
@@ -0,0 +1,87 @@
+//! Program operation handlers.
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_program_close(bridge: &mut GhidraBridge) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "program_close",
+        None
+    ).context("Failed to close program")?;
+
+    if response.status == "success" {
+        Ok(json!({"status": "closed"}).to_string())
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to close program".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_program_delete(
+    bridge: &mut GhidraBridge,
+    program_name: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "program_delete",
+        Some(json!({
+            "program": program_name
+        }))
+    ).context("Failed to delete program")?;
+
+    if response.status == "success" {
+        Ok(json!({"status": "deleted", "program": program_name}).to_string())
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to delete program".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_program_info(bridge: &mut GhidraBridge) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "program_info",
+        None
+    ).context("Failed to get program info")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to get program info".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_program_export(
+    bridge: &mut GhidraBridge,
+    format: &str,
+    output: Option<&str>
+) -> Result<String> {
+    let mut args = json!({
+        "format": format
+    });
+
+    if let Some(output_path) = output {
+        args["output"] = json!(output_path);
+    }
+
+    let response = bridge.send_command::<serde_json::Value>(
+        "program_export",
+        Some(args)
+    ).context("Failed to export program")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to export program".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+}
diff --git a/src/daemon/handlers/script.rs b/src/daemon/handlers/script.rs
new file mode 100644
index 0000000..c7b4769
--- /dev/null
+++ b/src/daemon/handlers/script.rs
@@ -0,0 +1,89 @@
+//! Script execution handlers.
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_script_run(
+    bridge: &mut GhidraBridge,
+    path: &str,
+    args: &[String]
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "script_run",
+        Some(json!({"path": path, "args": args}))
+    ).context("Failed to run script")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to run script".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_script_python(
+    bridge: &mut GhidraBridge,
+    code: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "script_python",
+        Some(json!({"code": code}))
+    ).context("Failed to execute Python code")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to execute Python code".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_script_java(
+    bridge: &mut GhidraBridge,
+    code: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "script_java",
+        Some(json!({"code": code}))
+    ).context("Failed to execute Java code")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to execute Java code".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_script_list(bridge: &mut GhidraBridge) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "script_list",
+        None
+    ).context("Failed to list scripts")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to list scripts".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_script_placeholder() {
+        assert!(true);
+    }
+}
diff --git a/src/daemon/handlers/stats.rs b/src/daemon/handlers/stats.rs
new file mode 100644
index 0000000..da64cef
--- /dev/null
+++ b/src/daemon/handlers/stats.rs
@@ -0,0 +1,30 @@
+//! Program statistics handler.
+
+use anyhow::{Context, Result};
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_stats(bridge: &mut GhidraBridge) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "stats",
+        None
+    ).context("Failed to get program statistics")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(serde_json::json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to get program statistics".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_stats_placeholder() {
+        assert!(true);
+    }
+}
diff --git a/src/daemon/handlers/symbols.rs b/src/daemon/handlers/symbols.rs
new file mode 100644
index 0000000..7dca4c9
--- /dev/null
+++ b/src/daemon/handlers/symbols.rs
@@ -0,0 +1,135 @@
+//! Symbol operation handlers.
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_symbol_list(
+    bridge: &mut GhidraBridge,
+    filter: Option<&str>
+) -> Result<String> {
+    let args = if let Some(f) = filter {
+        Some(json!({"filter": f}))
+    } else {
+        None
+    };
+
+    let response = bridge.send_command::<serde_json::Value>(
+        "symbol_list",
+        args
+    ).context("Failed to list symbols")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to list symbols".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_symbol_get(
+    bridge: &mut GhidraBridge,
+    address: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "symbol_get",
+        Some(json!({"address": address}))
+    ).context("Failed to get symbol")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to get symbol".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_symbol_create(
+    bridge: &mut GhidraBridge,
+    address: &str,
+    name: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "symbol_create",
+        Some(json!({
+            "address": address,
+            "name": name
+        }))
+    ).context("Failed to create symbol")?;
+
+    if response.status == "success" {
+        Ok(json!({"status": "created", "address": address, "name": name}).to_string())
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to create symbol".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_symbol_delete(
+    bridge: &mut GhidraBridge,
+    name: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "symbol_delete",
+        Some(json!({"name": name}))
+    ).context("Failed to delete symbol")?;
+
+    if response.status == "success" {
+        Ok(json!({"status": "deleted", "name": name}).to_string())
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to delete symbol".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_symbol_rename(
+    bridge: &mut GhidraBridge,
+    old_name: &str,
+    new_name: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "symbol_rename",
+        Some(json!({
+            "old_name": old_name,
+            "new_name": new_name
+        }))
+    ).context("Failed to rename symbol")?;
+
+    if response.status == "success" {
+        Ok(json!({"status": "renamed", "old_name": old_name, "new_name": new_name}).to_string())
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to rename symbol".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+/// Resolve address input - handles both hex addresses and symbol names.
+/// The actual resolution is done on the Python side.
+#[allow(dead_code)]
+fn resolve_address(input: &str) -> Result<String> {
+    // Pass-through to Python layer which handles both hex addresses and symbol name lookups
+    if input.starts_with("0x") || input.chars().all(|c| c.is_ascii_hexdigit()) {
+        Ok(input.to_string())
+    } else {
+        Ok(input.to_string())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_resolve_address_hex() {
+        assert_eq!(resolve_address("0x1000").unwrap(), "0x1000");
+    }
+
+    #[test]
+    fn test_resolve_address_name() {
+        assert_eq!(resolve_address("main").unwrap(), "main");
+    }
+}
diff --git a/src/daemon/handlers/types.rs b/src/daemon/handlers/types.rs
new file mode 100644
index 0000000..a284ca2
--- /dev/null
+++ b/src/daemon/handlers/types.rs
@@ -0,0 +1,83 @@
+//! Type operation handlers.
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use crate::ghidra::bridge::GhidraBridge;
+
+pub async fn handle_type_list(bridge: &mut GhidraBridge) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "type_list",
+        None
+    ).context("Failed to list types")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to list types".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_type_get(
+    bridge: &mut GhidraBridge,
+    name: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "type_get",
+        Some(json!({"name": name}))
+    ).context("Failed to get type")?;
+
+    if response.status == "success" {
+        let data = response.data.unwrap_or(json!({}));
+        serde_json::to_string_pretty(&data)
+            .context("Failed to serialize response")
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to get type".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_type_create(
+    bridge: &mut GhidraBridge,
+    name: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "type_create",
+        Some(json!({"name": name}))
+    ).context("Failed to create type")?;
+
+    if response.status == "success" {
+        Ok(json!({"status": "created", "name": name}).to_string())
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to create type".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+pub async fn handle_type_apply(
+    bridge: &mut GhidraBridge,
+    address: &str,
+    type_name: &str
+) -> Result<String> {
+    let response = bridge.send_command::<serde_json::Value>(
+        "type_apply",
+        Some(json!({
+            "address": address,
+            "type_name": type_name
+        }))
+    ).context("Failed to apply type")?;
+
+    if response.status == "success" {
+        Ok(json!({"status": "applied", "address": address, "type": type_name}).to_string())
+    } else {
+        let message = response.message.unwrap_or_else(|| "Failed to apply type".to_string());
+        anyhow::bail!("{}", message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+}
diff --git a/src/daemon/mod.rs b/src/daemon/mod.rs
index 503962a..955914a 100644
--- a/src/daemon/mod.rs
+++ b/src/daemon/mod.rs
@@ -17,6 +17,7 @@ use crate::ghidra::bridge::GhidraBridge;
 
 pub mod cache;
 pub mod handler;
+pub mod handlers;
 pub mod ipc_server;
 pub mod process;
 pub mod queue;
diff --git a/src/daemon/queue.rs b/src/daemon/queue.rs
index 8f29265..70f82a2 100644
--- a/src/daemon/queue.rs
+++ b/src/daemon/queue.rs
@@ -14,6 +14,7 @@ use tracing::{info, warn};
 
 use crate::cli::Commands;
 use crate::daemon::cache::Cache;
+use crate::daemon::handlers;
 use crate::ghidra::bridge::GhidraBridge;
 
 /// A queued command waiting to be executed.
@@ -210,6 +211,222 @@ async fn execute_command(
                 XRefCommands::List(_) => anyhow::bail!("XRef List not yet supported"),
             }
         },
+        Commands::Program(prog_cmd) => {
+            use crate::cli::ProgramCommands;
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return match prog_cmd {
+                ProgramCommands::Close(_) => handlers::program::handle_program_close(bridge_ref).await,
+                ProgramCommands::Delete(args) => {
+                    let program = args.program.as_ref()
+                        .ok_or_else(|| anyhow::anyhow!("Program name required"))?;
+                    handlers::program::handle_program_delete(bridge_ref, program).await
+                },
+                ProgramCommands::Info(_) => handlers::program::handle_program_info(bridge_ref).await,
+                ProgramCommands::Export(args) => {
+                    handlers::program::handle_program_export(bridge_ref, &args.format, args.output.as_deref()).await
+                },
+            };
+        },
+        Commands::Symbol(sym_cmd) => {
+            use crate::cli::SymbolCommands;
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return match sym_cmd {
+                SymbolCommands::List(opts) => {
+                    handlers::symbols::handle_symbol_list(bridge_ref, opts.filter.as_deref()).await
+                },
+                SymbolCommands::Get(args) => {
+                    handlers::symbols::handle_symbol_get(bridge_ref, &args.name).await
+                },
+                SymbolCommands::Create(args) => {
+                    handlers::symbols::handle_symbol_create(bridge_ref, &args.address, &args.name).await
+                },
+                SymbolCommands::Delete(args) => {
+                    handlers::symbols::handle_symbol_delete(bridge_ref, &args.name).await
+                },
+                SymbolCommands::Rename(args) => {
+                    handlers::symbols::handle_symbol_rename(bridge_ref, &args.old_name, &args.new_name).await
+                },
+            };
+        },
+        Commands::Type(type_cmd) => {
+            use crate::cli::TypeCommands;
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return match type_cmd {
+                TypeCommands::List(_) => {
+                    handlers::types::handle_type_list(bridge_ref).await
+                },
+                TypeCommands::Get(args) => {
+                    handlers::types::handle_type_get(bridge_ref, &args.name).await
+                },
+                TypeCommands::Create(args) => {
+                    handlers::types::handle_type_create(bridge_ref, &args.definition).await
+                },
+                TypeCommands::Apply(args) => {
+                    handlers::types::handle_type_apply(bridge_ref, &args.address, &args.type_name).await
+                },
+            };
+        },
+        Commands::Comment(comment_cmd) => {
+            use crate::cli::CommentCommands;
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return match comment_cmd {
+                CommentCommands::List(_) => handlers::comments::handle_comment_list(bridge_ref).await,
+                CommentCommands::Get(args) => handlers::comments::handle_comment_get(bridge_ref, &args.address).await,
+                CommentCommands::Set(args) => {
+                    handlers::comments::handle_comment_set(bridge_ref, &args.address, &args.text, args.comment_type.as_deref()).await
+                },
+                CommentCommands::Delete(args) => handlers::comments::handle_comment_delete(bridge_ref, &args.address).await,
+            };
+        },
+        Commands::Graph(graph_cmd) => {
+            use crate::cli::GraphCommands;
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return match graph_cmd {
+                GraphCommands::Calls(opts) => {
+                    handlers::graph::handle_graph_calls(bridge_ref, opts.limit).await
+                },
+                GraphCommands::Callers(args) => {
+                    handlers::graph::handle_graph_callers(bridge_ref, &args.function, args.depth).await
+                },
+                GraphCommands::Callees(args) => {
+                    handlers::graph::handle_graph_callees(bridge_ref, &args.function, args.depth).await
+                },
+                GraphCommands::Export(args) => {
+                    handlers::graph::handle_graph_export(bridge_ref, &args.format).await
+                },
+            };
+        },
+        Commands::Find(find_cmd) => {
+            use crate::cli::FindCommands;
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return match find_cmd {
+                FindCommands::String(args) => handlers::find::handle_find_string(bridge_ref, &args.pattern).await,
+                FindCommands::Bytes(args) => handlers::find::handle_find_bytes(bridge_ref, &args.hex).await,
+                FindCommands::Function(args) => handlers::find::handle_find_function(bridge_ref, &args.pattern).await,
+                FindCommands::Calls(args) => handlers::find::handle_find_calls(bridge_ref, &args.function).await,
+                FindCommands::Crypto(_) => handlers::find::handle_find_crypto(bridge_ref).await,
+                FindCommands::Interesting(_) => handlers::find::handle_find_interesting(bridge_ref).await,
+            };
+        },
+        Commands::Diff(diff_cmd) => {
+            use crate::cli::DiffCommands;
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return match diff_cmd {
+                DiffCommands::Programs(args) => {
+                    handlers::diff::handle_diff_programs(bridge_ref, &args.program1, &args.program2).await
+                },
+                DiffCommands::Functions(args) => {
+                    handlers::diff::handle_diff_functions(bridge_ref, &args.func1, &args.func2).await
+                },
+            };
+        },
+        Commands::Patch(patch_cmd) => {
+            use crate::cli::PatchCommands;
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return match patch_cmd {
+                PatchCommands::Bytes(args) => handlers::patch::handle_patch_bytes(bridge_ref, &args.address, &args.hex).await,
+                PatchCommands::Nop(args) => handlers::patch::handle_patch_nop(bridge_ref, &args.address).await,
+                PatchCommands::Export(args) => handlers::patch::handle_patch_export(bridge_ref, &args.output).await,
+            };
+        },
+        Commands::Script(script_cmd) => {
+            use crate::cli::ScriptCommands;
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return match script_cmd {
+                ScriptCommands::Run(args) => handlers::script::handle_script_run(bridge_ref, &args.script_path, &args.args).await,
+                ScriptCommands::Python(args) => handlers::script::handle_script_python(bridge_ref, &args.code).await,
+                ScriptCommands::Java(args) => handlers::script::handle_script_java(bridge_ref, &args.code).await,
+                ScriptCommands::List => handlers::script::handle_script_list(bridge_ref).await,
+            };
+        },
+        Commands::Disasm(args) => {
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return handlers::disasm::handle_disasm(bridge_ref, &args.address, args.num_instructions).await;
+        },
+        Commands::Batch(args) => {
+            return handlers::batch::handle_batch(&args.script_file).await;
+        },
+        Commands::Stats(_) => {
+            let mut bridge_guard = bridge.lock().await;
+            let bridge_ref = bridge_guard.as_mut()
+                .ok_or_else(|| anyhow::anyhow!("Bridge not initialized"))?;
+
+            if !bridge_ref.is_running() {
+                anyhow::bail!("Bridge is not running");
+            }
+
+            return handlers::stats::handle_stats(bridge_ref).await;
+        },
         Commands::Summary(_) => ("program_info", None),
         _ => anyhow::bail!("Command not yet supported in daemon: {:?}", command),
     };
@@ -236,6 +453,15 @@ async fn execute_command(
     }
 }
 
+/// Execute a CLI command directly (for IPC handler use).
+/// This bypasses the queue and executes immediately.
+pub async fn execute_command_direct(
+    bridge: &Arc<Mutex<Option<GhidraBridge>>>,
+    command: &Commands,
+) -> Result<String> {
+    execute_command(&PathBuf::new(), bridge, command).await
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/ghidra/scripts/batch.py b/src/ghidra/scripts/batch.py
new file mode 100644
index 0000000..9b2b0ee
--- /dev/null
+++ b/src/ghidra/scripts/batch.py
@@ -0,0 +1,22 @@
+# Batch operations script
+# @category CLI
+#
+# Note: Batch operations are handled directly in Rust handler.
+# This script exists for consistency but is not actively used.
+
+import sys
+import json
+
+def batch_placeholder():
+    """Placeholder function - batch operations handled in Rust."""
+    return {"error": "Batch operations are handled by the Rust daemon, not via Python script"}
+
+if __name__ == "__main__":
+    try:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(batch_placeholder()))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/bridge.py b/src/ghidra/scripts/bridge.py
index e2a98b8..f23f3ef 100644
--- a/src/ghidra/scripts/bridge.py
+++ b/src/ghidra/scripts/bridge.py
@@ -256,24 +256,24 @@ def handle_xrefs_from(args):
     """Get cross-references from an address."""
     if currentProgram is None:
         return {"error": "No program loaded"}
-    
+
     addr_str = args.get("address")
     if not addr_str:
         return {"error": "No address provided"}
-    
+
     addr = currentProgram.getAddressFactory().getAddress(addr_str)
     if addr is None:
         return {"error": "Invalid address: " + addr_str}
-    
+
     xrefs = []
     refs = currentProgram.getReferenceManager().getReferencesFrom(addr)
     function_manager = currentProgram.getFunctionManager()
-    
+
     for ref in refs:
         to_addr = ref.getToAddress()
         from_func = function_manager.getFunctionContaining(addr)
         to_func = function_manager.getFunctionContaining(to_addr)
-        
+
         xref_data = {
             "from": str(addr),
             "to": str(to_addr),
@@ -282,14 +282,509 @@ def handle_xrefs_from(args):
             "to_function": to_func.getName() if to_func else None
         }
         xrefs.append(xref_data)
-    
+
     return {"xrefs": xrefs, "count": len(xrefs)}
 
+def handle_program_close(args):
+    """Close the current program."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    program_name = currentProgram.getName()
+    state.getTool().closeProgram(currentProgram, False)
+
+    return {"status": "closed", "program": program_name}
+
+def handle_program_delete(args):
+    """Delete a program from the project."""
+    program_name = args.get("program")
+    if not program_name:
+        return {"error": "Program name required"}
+
+    project = state.getProject()
+    if project is None:
+        return {"error": "No project open"}
+
+    project_data = project.getProjectData()
+
+    try:
+        program_file = project_data.getFile(program_name)
+        if program_file is None:
+            return {"error": "Program not found: " + program_name}
+
+        project_data.deleteFile(program_name)
+        return {"status": "deleted", "program": program_name}
+    except Exception as e:
+        return {"error": "Failed to delete program: " + str(e)}
+
+def handle_program_export(args):
+    """Export program to specified format."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    export_format = args.get("format", "json")
+    output_path = args.get("output")
+
+    if export_format == "json":
+        data = handle_program_info({})
+        if "error" in data:
+            return data
+
+        function_manager = currentProgram.getFunctionManager()
+        functions = []
+        for func in function_manager.getFunctions(True):
+            functions.append({
+                "name": func.getName(),
+                "address": str(func.getEntryPoint()),
+                "size": func.getBody().getNumAddresses()
+            })
+        data["functions"] = functions
+
+        if output_path:
+            try:
+                with open(output_path, 'w') as f:
+                    json.dump(data, f, indent=2)
+                return {"status": "exported", "format": "json", "output": output_path}
+            except Exception as e:
+                return {"error": "Failed to write file: " + str(e)}
+        else:
+            return data
+    else:
+        return {"error": "Unsupported export format: " + export_format}
+
 # --- Command Router ---
 
+def handle_find_string(args):
+    """Find string references."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import find
+        return find.find_strings(args.get("pattern", ""))
+    except Exception as e:
+        return {"error": "Failed to find strings: " + str(e)}
+
+def handle_find_bytes(args):
+    """Find byte patterns."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import find
+        return find.find_bytes(args.get("hex", ""))
+    except Exception as e:
+        return {"error": "Failed to find bytes: " + str(e)}
+
+def handle_find_function(args):
+    """Find functions by pattern."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import find
+        return find.find_functions(args.get("pattern", ""))
+    except Exception as e:
+        return {"error": "Failed to find functions: " + str(e)}
+
+def handle_find_calls(args):
+    """Find calls to function."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import find
+        return find.find_calls(args.get("function", ""))
+    except Exception as e:
+        return {"error": "Failed to find calls: " + str(e)}
+
+def handle_find_crypto(args):
+    """Find crypto constants."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import find
+        return find.find_crypto()
+    except Exception as e:
+        return {"error": "Failed to find crypto: " + str(e)}
+
+def handle_find_interesting(args):
+    """Find interesting functions."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import find
+        return find.find_interesting()
+    except Exception as e:
+        return {"error": "Failed to find interesting: " + str(e)}
+
+def handle_script_run(args):
+    """Run a script file."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import script_runner
+        return script_runner.run_script(args.get("path", ""), args.get("args", []))
+    except Exception as e:
+        return {"error": "Failed to run script: " + str(e)}
+
+def handle_script_python(args):
+    """Execute Python code."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import script_runner
+        return script_runner.exec_python(args.get("code", ""))
+    except Exception as e:
+        return {"error": "Failed to execute Python: " + str(e)}
+
+def handle_script_java(args):
+    """Execute Java code."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import script_runner
+        return script_runner.exec_java(args.get("code", ""))
+    except Exception as e:
+        return {"error": "Failed to execute Java: " + str(e)}
+
+def handle_script_list(args):
+    """List available scripts."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import script_runner
+        return script_runner.list_scripts()
+    except Exception as e:
+        return {"error": "Failed to list scripts: " + str(e)}
+
+# --- Symbol Handlers ---
+
+def handle_symbol_list(args):
+    """List symbols."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import symbols
+        return symbols.list_symbols(args.get("filter"))
+    except Exception as e:
+        return {"error": "Failed to list symbols: " + str(e)}
+
+def handle_symbol_get(args):
+    """Get symbol details."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import symbols
+        return symbols.get_symbol(args.get("name", ""))
+    except Exception as e:
+        return {"error": "Failed to get symbol: " + str(e)}
+
+def handle_symbol_create(args):
+    """Create a symbol."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import symbols
+        return symbols.create_symbol(args.get("address", ""), args.get("name", ""))
+    except Exception as e:
+        return {"error": "Failed to create symbol: " + str(e)}
+
+def handle_symbol_delete(args):
+    """Delete a symbol."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import symbols
+        return symbols.delete_symbol(args.get("name", ""))
+    except Exception as e:
+        return {"error": "Failed to delete symbol: " + str(e)}
+
+def handle_symbol_rename(args):
+    """Rename a symbol."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import symbols
+        return symbols.rename_symbol(args.get("old_name", ""), args.get("new_name", ""))
+    except Exception as e:
+        return {"error": "Failed to rename symbol: " + str(e)}
+
+# --- Type Handlers ---
+
+def handle_type_list(args):
+    """List data types."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import types
+        return types.list_types()
+    except Exception as e:
+        return {"error": "Failed to list types: " + str(e)}
+
+def handle_type_get(args):
+    """Get type details."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import types
+        return types.get_type(args.get("name", ""))
+    except Exception as e:
+        return {"error": "Failed to get type: " + str(e)}
+
+def handle_type_create(args):
+    """Create a data type."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import types
+        # The Python script expects a type name; CLI passes "definition" as the name
+        return types.create_type(args.get("definition", args.get("name", "")))
+    except Exception as e:
+        return {"error": "Failed to create type: " + str(e)}
+
+def handle_type_apply(args):
+    """Apply a type to an address."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import types
+        return types.apply_type(args.get("address", ""), args.get("type_name", ""))
+    except Exception as e:
+        return {"error": "Failed to apply type: " + str(e)}
+
+# --- Comment Handlers ---
+
+def handle_comment_list(args):
+    """List comments."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import comments
+        return comments.list_comments()
+    except Exception as e:
+        return {"error": "Failed to list comments: " + str(e)}
+
+def handle_comment_get(args):
+    """Get comments at address."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import comments
+        return comments.get_comments(args.get("address", ""))
+    except Exception as e:
+        return {"error": "Failed to get comments: " + str(e)}
+
+def handle_comment_set(args):
+    """Set a comment at address."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import comments
+        return comments.set_comment(args.get("address", ""), args.get("text", ""), args.get("comment_type"))
+    except Exception as e:
+        return {"error": "Failed to set comment: " + str(e)}
+
+def handle_comment_delete(args):
+    """Delete comment at address."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import comments
+        return comments.delete_comment(args.get("address", ""))
+    except Exception as e:
+        return {"error": "Failed to delete comment: " + str(e)}
+
+# --- Graph Handlers ---
+
+def handle_graph_calls(args):
+    """Get call graph."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import graph
+        return graph.get_call_graph(args.get("limit"))
+    except Exception as e:
+        return {"error": "Failed to get call graph: " + str(e)}
+
+def handle_graph_callers(args):
+    """Get callers of a function."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import graph
+        return graph.get_callers(args.get("function", ""), args.get("depth", 1))
+    except Exception as e:
+        return {"error": "Failed to get callers: " + str(e)}
+
+def handle_graph_callees(args):
+    """Get callees of a function."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import graph
+        return graph.get_callees(args.get("function", ""), args.get("depth", 1))
+    except Exception as e:
+        return {"error": "Failed to get callees: " + str(e)}
+
+def handle_graph_export(args):
+    """Export call graph."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import graph
+        return graph.export_graph(args.get("format", "dot"))
+    except Exception as e:
+        return {"error": "Failed to export graph: " + str(e)}
+
+# --- Diff Handlers ---
+
+def handle_diff_programs(args):
+    """Diff two programs."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import diff
+        return diff.diff_programs(args.get("program1", ""), args.get("program2", ""))
+    except Exception as e:
+        return {"error": "Failed to diff programs: " + str(e)}
+
+def handle_diff_functions(args):
+    """Diff two functions."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import diff
+        return diff.diff_functions(args.get("func1", ""), args.get("func2", ""))
+    except Exception as e:
+        return {"error": "Failed to diff functions: " + str(e)}
+
+# --- Patch Handlers ---
+
+def handle_patch_bytes(args):
+    """Patch bytes at address."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import patch
+        return patch.patch_bytes(args.get("address", ""), args.get("hex", ""))
+    except Exception as e:
+        return {"error": "Failed to patch bytes: " + str(e)}
+
+def handle_patch_nop(args):
+    """NOP instruction at address."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import patch
+        return patch.patch_nop(args.get("address", ""))
+    except Exception as e:
+        return {"error": "Failed to NOP: " + str(e)}
+
+def handle_patch_export(args):
+    """Export patches."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import patch
+        return patch.export_patches(args.get("output", ""))
+    except Exception as e:
+        return {"error": "Failed to export patches: " + str(e)}
+
+# --- Disasm Handler ---
+
+def handle_disasm(args):
+    """Disassemble at address."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import disasm
+        return disasm.disassemble(args.get("address", ""), args.get("count", 10))
+    except Exception as e:
+        return {"error": "Failed to disassemble: " + str(e)}
+
+# --- Stats Handler ---
+
+def handle_stats(args):
+    """Get program statistics."""
+    import sys
+    import os
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    sys.path.insert(0, script_dir)
+    try:
+        import stats
+        return stats.get_stats()
+    except Exception as e:
+        return {"error": "Failed to get stats: " + str(e)}
+
 COMMANDS = {
     "ping": handle_ping,
     "program_info": handle_program_info,
+    "program_close": handle_program_close,
+    "program_delete": handle_program_delete,
+    "program_export": handle_program_export,
     "list_functions": handle_list_functions,
     "decompile": handle_decompile,
     "list_strings": handle_list_strings,
@@ -298,6 +793,47 @@ COMMANDS = {
     "memory_map": handle_memory_map,
     "xrefs_to": handle_xrefs_to,
     "xrefs_from": handle_xrefs_from,
+    "find_string": handle_find_string,
+    "find_bytes": handle_find_bytes,
+    "find_function": handle_find_function,
+    "find_calls": handle_find_calls,
+    "find_crypto": handle_find_crypto,
+    "find_interesting": handle_find_interesting,
+    "script_run": handle_script_run,
+    "script_python": handle_script_python,
+    "script_java": handle_script_java,
+    "script_list": handle_script_list,
+    # Symbol commands
+    "symbol_list": handle_symbol_list,
+    "symbol_get": handle_symbol_get,
+    "symbol_create": handle_symbol_create,
+    "symbol_delete": handle_symbol_delete,
+    "symbol_rename": handle_symbol_rename,
+    # Type commands
+    "type_list": handle_type_list,
+    "type_get": handle_type_get,
+    "type_create": handle_type_create,
+    "type_apply": handle_type_apply,
+    # Comment commands
+    "comment_list": handle_comment_list,
+    "comment_get": handle_comment_get,
+    "comment_set": handle_comment_set,
+    "comment_delete": handle_comment_delete,
+    # Graph commands
+    "graph_calls": handle_graph_calls,
+    "graph_callers": handle_graph_callers,
+    "graph_callees": handle_graph_callees,
+    "graph_export": handle_graph_export,
+    # Diff commands
+    "diff_programs": handle_diff_programs,
+    "diff_functions": handle_diff_functions,
+    # Patch commands
+    "patch_bytes": handle_patch_bytes,
+    "patch_nop": handle_patch_nop,
+    "patch_export": handle_patch_export,
+    # Other commands
+    "disasm": handle_disasm,
+    "stats": handle_stats,
 }
 
 # --- Server Logic ---
diff --git a/src/ghidra/scripts/comments.py b/src/ghidra/scripts/comments.py
new file mode 100644
index 0000000..5bf72b4
--- /dev/null
+++ b/src/ghidra/scripts/comments.py
@@ -0,0 +1,161 @@
+# Comment operations script
+# @category CLI
+
+import sys
+import json
+
+def list_comments():
+    """List all comments in the program."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    listing = currentProgram.getListing()
+    comments = []
+
+    code_unit_iter = listing.getCommentAddressIterator(currentProgram.getMinAddress(), currentProgram.getMaxAddress(), True)
+
+    for addr in code_unit_iter:
+        code_unit = listing.getCodeUnitAt(addr)
+        if code_unit is None:
+            continue
+
+        from ghidra.program.model.listing import CodeUnit
+
+        comment_types = [
+            ("EOL", CodeUnit.EOL_COMMENT),
+            ("PRE", CodeUnit.PRE_COMMENT),
+            ("POST", CodeUnit.POST_COMMENT),
+            ("PLATE", CodeUnit.PLATE_COMMENT)
+        ]
+
+        for comment_name, comment_type in comment_types:
+            text = code_unit.getComment(comment_type)
+            if text:
+                comments.append({
+                    "address": str(addr),
+                    "type": comment_name,
+                    "text": text
+                })
+
+    return {"comments": comments, "count": len(comments)}
+
+def get_comments(address_str):
+    """Get comments at a specific address."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        addr = currentProgram.getAddressFactory().getAddress(address_str)
+        if addr is None:
+            return {"error": "Invalid address: " + address_str}
+
+        listing = currentProgram.getListing()
+        code_unit = listing.getCodeUnitAt(addr)
+
+        if code_unit is None:
+            return {"error": "No code unit at address: " + address_str}
+
+        from ghidra.program.model.listing import CodeUnit
+
+        comments = []
+        comment_types = [
+            ("EOL", CodeUnit.EOL_COMMENT),
+            ("PRE", CodeUnit.PRE_COMMENT),
+            ("POST", CodeUnit.POST_COMMENT),
+            ("PLATE", CodeUnit.PLATE_COMMENT)
+        ]
+
+        for comment_name, comment_type in comment_types:
+            text = code_unit.getComment(comment_type)
+            if text:
+                comments.append({
+                    "type": comment_name,
+                    "text": text
+                })
+
+        return {"address": address_str, "comments": comments}
+    except Exception as e:
+        return {"error": "Failed to get comments: " + str(e)}
+
+def set_comment(address_str, text, comment_type_str):
+    """Set a comment at a specific address."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        addr = currentProgram.getAddressFactory().getAddress(address_str)
+        if addr is None:
+            return {"error": "Invalid address: " + address_str}
+
+        listing = currentProgram.getListing()
+        from ghidra.program.model.listing import CodeUnit
+
+        valid_types = {"EOL", "PRE", "POST", "PLATE"}
+        if comment_type_str not in valid_types:
+            return {"error": "Invalid comment type: " + comment_type_str + ". Must be one of: EOL, PRE, POST, PLATE"}
+
+        comment_type = CodeUnit.EOL_COMMENT
+        if comment_type_str == "PRE":
+            comment_type = CodeUnit.PRE_COMMENT
+        elif comment_type_str == "POST":
+            comment_type = CodeUnit.POST_COMMENT
+        elif comment_type_str == "PLATE":
+            comment_type = CodeUnit.PLATE_COMMENT
+
+        listing.setComment(addr, comment_type, text)
+        return {"status": "set", "address": address_str}
+    except Exception as e:
+        return {"error": "Failed to set comment: " + str(e)}
+
+def delete_comment(address_str):
+    """Delete all comments at a specific address."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        addr = currentProgram.getAddressFactory().getAddress(address_str)
+        if addr is None:
+            return {"error": "Invalid address: " + address_str}
+
+        listing = currentProgram.getListing()
+        from ghidra.program.model.listing import CodeUnit
+
+        listing.setComment(addr, CodeUnit.EOL_COMMENT, None)
+        listing.setComment(addr, CodeUnit.PRE_COMMENT, None)
+        listing.setComment(addr, CodeUnit.POST_COMMENT, None)
+        listing.setComment(addr, CodeUnit.PLATE_COMMENT, None)
+
+        return {"status": "deleted", "address": address_str}
+    except Exception as e:
+        return {"error": "Failed to delete comment: " + str(e)}
+
+if __name__ == "__main__":
+    try:
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "list":
+            result = list_comments()
+        elif command == "get":
+            result = get_comments(args[1] if len(args) > 1 else None)
+        elif command == "set":
+            text = args[2] if len(args) > 2 else ""
+            comment_type = args[3] if len(args) > 3 else "EOL"
+            result = set_comment(args[1] if len(args) > 1 else None, text, comment_type)
+        elif command == "delete":
+            result = delete_comment(args[1] if len(args) > 1 else None)
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/diff.py b/src/ghidra/scripts/diff.py
new file mode 100644
index 0000000..340bea1
--- /dev/null
+++ b/src/ghidra/scripts/diff.py
@@ -0,0 +1,132 @@
+# Diff operations script
+# @category CLI
+
+import sys
+import json
+
+def diff_programs(prog1, prog2):
+    """Compare two programs structurally."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        func_manager = currentProgram.getFunctionManager()
+        memory = currentProgram.getMemory()
+        symbol_table = currentProgram.getSymbolTable()
+
+        prog1_stats = {
+            "name": prog1,
+            "function_count": func_manager.getFunctionCount(),
+            "memory_size": memory.getSize(),
+            "symbol_count": symbol_table.getNumSymbols()
+        }
+
+        memory_blocks = []
+        for block in memory.getBlocks():
+            memory_blocks.append({
+                "name": block.getName(),
+                "start": str(block.getStart()),
+                "end": str(block.getEnd()),
+                "size": block.getSize()
+            })
+
+        prog1_stats["memory_blocks"] = memory_blocks
+
+        return {
+            "program1": prog1_stats,
+            "program2": {"name": prog2, "note": "Comparison requires loading second program"},
+            "status": "partial",
+            "message": "Single program stats returned (multi-program comparison not implemented)"
+        }
+    except Exception as e:
+        return {"error": "Failed to diff programs: " + str(e)}
+
+def diff_functions(func1, func2):
+    """Compare two functions by decompilation."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        from ghidra.app.decompiler import DecompInterface
+
+        func_manager = currentProgram.getFunctionManager()
+
+        target_func1 = None
+        target_func2 = None
+
+        for func in func_manager.getFunctions(True):
+            if func.getName() == func1:
+                target_func1 = func
+            if func.getName() == func2:
+                target_func2 = func
+
+        if target_func1 is None:
+            return {"error": "Function not found: " + func1}
+        if target_func2 is None:
+            return {"error": "Function not found: " + func2}
+
+        decompiler = DecompInterface()
+        decompiler.openProgram(currentProgram)
+
+        result1 = decompiler.decompileFunction(target_func1, 30, monitor)
+        result2 = decompiler.decompileFunction(target_func2, 30, monitor)
+
+        if not result1.decompileCompleted():
+            return {"error": "Failed to decompile " + func1}
+        if not result2.decompileCompleted():
+            return {"error": "Failed to decompile " + func2}
+
+        code1 = result1.getDecompiledFunction().getC()
+        code2 = result2.getDecompiledFunction().getC()
+
+        lines1 = code1.split('\n')
+        lines2 = code2.split('\n')
+
+        diff_lines = []
+        max_lines = max(len(lines1), len(lines2))
+
+        for i in range(max_lines):
+            line1 = lines1[i] if i < len(lines1) else ""
+            line2 = lines2[i] if i < len(lines2) else ""
+
+            if line1 != line2:
+                diff_lines.append({
+                    "line": i + 1,
+                    "func1": line1,
+                    "func2": line2,
+                    "status": "changed"
+                })
+
+        return {
+            "func1": {"name": func1, "lines": len(lines1), "code": code1},
+            "func2": {"name": func2, "lines": len(lines2), "code": code2},
+            "differences": diff_lines,
+            "diff_count": len(diff_lines)
+        }
+    except Exception as e:
+        return {"error": "Failed to diff functions: " + str(e)}
+
+if __name__ == "__main__":
+    try:
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "diff_programs":
+            result = diff_programs(args[1] if len(args) > 1 else "", args[2] if len(args) > 2 else "")
+        elif command == "diff_functions":
+            result = diff_functions(args[1] if len(args) > 1 else "", args[2] if len(args) > 2 else "")
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/disasm.py b/src/ghidra/scripts/disasm.py
new file mode 100644
index 0000000..c7a6b54
--- /dev/null
+++ b/src/ghidra/scripts/disasm.py
@@ -0,0 +1,86 @@
+# Disassembly script
+# @category CLI
+
+import sys
+import json
+
+def disassemble(address_str, count):
+    """Disassemble instructions starting at address."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        addr_factory = currentProgram.getAddressFactory()
+
+        if address_str.startswith("0x") or address_str.startswith("0X"):
+            address_str = address_str[2:]
+
+        addr = addr_factory.getAddress(address_str)
+
+        if addr is None:
+            return {"error": "Invalid address: " + address_str}
+
+        listing = currentProgram.getListing()
+        instruction = listing.getInstructionAt(addr)
+
+        if instruction is None:
+            return {"error": "No instruction at address: " + address_str}
+
+        results = []
+        current_instr = instruction
+
+        for i in range(count):
+            if current_instr is None:
+                break
+
+            instr_addr = current_instr.getAddress()
+
+            byte_array = current_instr.getBytes()
+            bytes_hex = ""
+            for b in byte_array:
+                bytes_hex += "{:02x}".format(b & 0xff)
+
+            mnemonic = current_instr.getMnemonicString()
+
+            operands = []
+            num_operands = current_instr.getNumOperands()
+            for j in range(num_operands):
+                operands.append(str(current_instr.getDefaultOperandRepresentation(j)))
+
+            results.append({
+                "address": str(instr_addr),
+                "bytes": bytes_hex,
+                "mnemonic": mnemonic,
+                "operands": operands
+            })
+
+            current_instr = current_instr.getNext()
+
+        return {"results": results, "count": len(results)}
+    except Exception as e:
+        return {"error": "Failed to disassemble: " + str(e)}
+
+if __name__ == "__main__":
+    try:
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "disasm":
+            address = args[1] if len(args) > 1 else "0x0"
+            count = int(args[2]) if len(args) > 2 else 10
+            result = disassemble(address, count)
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/find.py b/src/ghidra/scripts/find.py
new file mode 100644
index 0000000..e5bec06
--- /dev/null
+++ b/src/ghidra/scripts/find.py
@@ -0,0 +1,259 @@
+# Find/search operations script
+# @category CLI
+
+import sys
+import json
+
+def find_strings(pattern):
+    """Find string references matching pattern."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        listing = currentProgram.getListing()
+        results = []
+
+        data_iter = listing.getDefinedData(True)
+        while data_iter.hasNext():
+            data = data_iter.next()
+            if data.hasStringValue():
+                string_val = str(data.getValue())
+                if pattern.lower() in string_val.lower():
+                    results.append({
+                        "address": str(data.getAddress()),
+                        "value": string_val,
+                        "length": data.getLength()
+                    })
+
+        return {"results": results, "count": len(results)}
+    except Exception as e:
+        return {"error": "Failed to find strings: " + str(e)}
+
+def find_bytes(hex_pattern):
+    """Find byte patterns in memory."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        hex_clean = hex_pattern.replace("0x", "").replace(" ", "")
+
+        byte_array = []
+        for i in range(0, len(hex_clean), 2):
+            byte_val = int(hex_clean[i:i+2], 16)
+            if byte_val > 127:
+                byte_val = byte_val - 256
+            byte_array.append(byte_val)
+
+        from java.lang import Byte
+        search_bytes = [Byte(b) for b in byte_array]
+
+        memory = currentProgram.getMemory()
+        results = []
+
+        addr = memory.getMinAddress()
+        while addr is not None:
+            found_addr = memory.findBytes(addr, search_bytes, None, True, monitor)
+            if found_addr is None:
+                break
+            results.append({"address": str(found_addr)})
+            addr = found_addr.add(1)
+            if len(results) >= 100:
+                break
+
+        return {"results": results, "count": len(results)}
+    except Exception as e:
+        return {"error": "Failed to find bytes: " + str(e)}
+
+def find_functions(pattern):
+    """Find functions matching name pattern."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        func_manager = currentProgram.getFunctionManager()
+        results = []
+
+        for func in func_manager.getFunctions(True):
+            func_name = func.getName()
+
+            if "*" in pattern:
+                import fnmatch
+                if fnmatch.fnmatch(func_name, pattern):
+                    results.append({
+                        "name": func_name,
+                        "address": str(func.getEntryPoint()),
+                        "size": func.getBody().getNumAddresses()
+                    })
+            elif pattern.lower() in func_name.lower():
+                results.append({
+                    "name": func_name,
+                    "address": str(func.getEntryPoint()),
+                    "size": func.getBody().getNumAddresses()
+                })
+
+        return {"results": results, "count": len(results)}
+    except Exception as e:
+        return {"error": "Failed to find functions: " + str(e)}
+
+def find_calls(func_name):
+    """Find all calls to a specific function."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        func_manager = currentProgram.getFunctionManager()
+        target_func = None
+
+        for func in func_manager.getFunctions(True):
+            if func.getName() == func_name:
+                target_func = func
+                break
+
+        if target_func is None:
+            return {"error": "Function not found: " + func_name}
+
+        ref_manager = currentProgram.getReferenceManager()
+        target_addr = target_func.getEntryPoint()
+        refs = ref_manager.getReferencesTo(target_addr)
+
+        results = []
+        for ref in refs:
+            if ref.getReferenceType().isCall():
+                from_addr = ref.getFromAddress()
+                from_func = func_manager.getFunctionContaining(from_addr)
+
+                caller_name = "unknown"
+                if from_func is not None:
+                    caller_name = from_func.getName()
+
+                results.append({
+                    "address": str(from_addr),
+                    "caller": caller_name,
+                    "type": str(ref.getReferenceType())
+                })
+
+        return {"results": results, "count": len(results), "target": func_name}
+    except Exception as e:
+        return {"error": "Failed to find calls: " + str(e)}
+
+def find_crypto():
+    """Find potential crypto constants."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        memory = currentProgram.getMemory()
+        results = []
+
+        crypto_patterns = {
+            "AES S-box": "637c777bf26b6fc53001672bfed7ab76",
+            "SHA-256": "428a2f98d728ae227137449123ef65cd",
+            "MD5": "d76aa478e8c7b756242070db01234567",
+        }
+
+        for name, pattern in crypto_patterns.items():
+            hex_clean = pattern.replace(" ", "")
+            byte_array = []
+
+            for i in range(0, len(hex_clean), 2):
+                byte_val = int(hex_clean[i:i+2], 16)
+                if byte_val > 127:
+                    byte_val = byte_val - 256
+                byte_array.append(byte_val)
+
+            from java.lang import Byte
+            search_bytes = [Byte(b) for b in byte_array]
+
+            addr = memory.getMinAddress()
+            found_addr = memory.findBytes(addr, search_bytes, None, True, monitor)
+
+            if found_addr is not None:
+                results.append({
+                    "type": name,
+                    "address": str(found_addr),
+                    "pattern": pattern
+                })
+
+        return {"results": results, "count": len(results)}
+    except Exception as e:
+        return {"error": "Failed to find crypto: " + str(e)}
+
+def find_interesting():
+    """Find interesting functions using heuristics."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        func_manager = currentProgram.getFunctionManager()
+        ref_manager = currentProgram.getReferenceManager()
+        results = []
+
+        suspicious_names = ["password", "key", "encrypt", "decrypt", "crypt", "auth", "login", "admin", "secret"]
+
+        for func in func_manager.getFunctions(True):
+            func_name = func.getName()
+            func_addr = func.getEntryPoint()
+            func_size = func.getBody().getNumAddresses()
+
+            xref_count = len(list(ref_manager.getReferencesTo(func_addr)))
+
+            reasons = []
+
+            if func_size > 1000:
+                reasons.append("large function ({} bytes)".format(func_size))
+
+            if xref_count > 50:
+                reasons.append("many xrefs ({})".format(xref_count))
+
+            for sus_name in suspicious_names:
+                if sus_name in func_name.lower():
+                    reasons.append("suspicious name")
+                    break
+
+            if reasons:
+                results.append({
+                    "name": func_name,
+                    "address": str(func_addr),
+                    "size": func_size,
+                    "xrefs": xref_count,
+                    "reasons": reasons
+                })
+
+        results.sort(key=lambda x: len(x["reasons"]), reverse=True)
+
+        return {"results": results[:50], "count": len(results)}
+    except Exception as e:
+        return {"error": "Failed to find interesting functions: " + str(e)}
+
+if __name__ == "__main__":
+    try:
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "find_string":
+            result = find_strings(args[1] if len(args) > 1 else "")
+        elif command == "find_bytes":
+            result = find_bytes(args[1] if len(args) > 1 else "")
+        elif command == "find_function":
+            result = find_functions(args[1] if len(args) > 1 else "")
+        elif command == "find_calls":
+            result = find_calls(args[1] if len(args) > 1 else "")
+        elif command == "find_crypto":
+            result = find_crypto()
+        elif command == "find_interesting":
+            result = find_interesting()
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/graph.py b/src/ghidra/scripts/graph.py
new file mode 100644
index 0000000..1151ab2
--- /dev/null
+++ b/src/ghidra/scripts/graph.py
@@ -0,0 +1,223 @@
+# Graph operations script
+# @category CLI
+
+import sys
+import json
+
+def get_call_graph(limit):
+    """Build full call graph."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    function_manager = currentProgram.getFunctionManager()
+    reference_manager = currentProgram.getReferenceManager()
+
+    nodes = []
+    edges = []
+    count = 0
+
+    for func in function_manager.getFunctions(True):
+        if limit and count >= limit:
+            break
+
+        func_addr = str(func.getEntryPoint())
+        nodes.append({
+            "id": func_addr,
+            "name": func.getName(),
+            "address": func_addr
+        })
+
+        from ghidra.program.model.symbol import RefType
+        refs = reference_manager.getReferencesFrom(func.getEntryPoint())
+        for ref in refs:
+            if ref.getReferenceType().isCall():
+                target_addr = ref.getToAddress()
+                target_func = function_manager.getFunctionAt(target_addr)
+                if target_func:
+                    edges.append({
+                        "from": func_addr,
+                        "to": str(target_addr),
+                        "type": "call"
+                    })
+
+        count += 1
+
+    return {"nodes": nodes, "edges": edges, "node_count": len(nodes), "edge_count": len(edges)}
+
+def get_callers(function_name, depth):
+    """Get functions that call the specified function."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    function_manager = currentProgram.getFunctionManager()
+    reference_manager = currentProgram.getReferenceManager()
+
+    target_func = None
+    if function_name.startswith("0x") or all(c in "0123456789abcdefABCDEF" for c in function_name):
+        addr = currentProgram.getAddressFactory().getAddress(function_name)
+        if addr:
+            target_func = function_manager.getFunctionAt(addr)
+    else:
+        for func in function_manager.getFunctions(True):
+            if func.getName() == function_name:
+                target_func = func
+                break
+
+    if not target_func:
+        return {"error": "Function not found: " + function_name}
+
+    callers = []
+    visited = set()
+
+    def find_callers(func, current_depth):
+        if depth and current_depth >= depth:
+            return
+        if str(func.getEntryPoint()) in visited:
+            return
+
+        visited.add(str(func.getEntryPoint()))
+
+        from ghidra.program.model.symbol import RefType
+        refs = reference_manager.getReferencesTo(func.getEntryPoint())
+
+        for ref in refs:
+            if ref.getReferenceType().isCall():
+                from_addr = ref.getFromAddress()
+                caller_func = function_manager.getFunctionContaining(from_addr)
+                if caller_func:
+                    caller_info = {
+                        "name": caller_func.getName(),
+                        "address": str(caller_func.getEntryPoint()),
+                        "call_site": str(from_addr),
+                        "depth": current_depth
+                    }
+                    callers.append(caller_info)
+
+                    if depth is None or current_depth + 1 < depth:
+                        find_callers(caller_func, current_depth + 1)
+
+    find_callers(target_func, 0)
+
+    return {"function": function_name, "callers": callers, "count": len(callers)}
+
+def get_callees(function_name, depth):
+    """Get functions called by the specified function."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    function_manager = currentProgram.getFunctionManager()
+    reference_manager = currentProgram.getReferenceManager()
+
+    target_func = None
+    if function_name.startswith("0x") or all(c in "0123456789abcdefABCDEF" for c in function_name):
+        addr = currentProgram.getAddressFactory().getAddress(function_name)
+        if addr:
+            target_func = function_manager.getFunctionAt(addr)
+    else:
+        for func in function_manager.getFunctions(True):
+            if func.getName() == function_name:
+                target_func = func
+                break
+
+    if not target_func:
+        return {"error": "Function not found: " + function_name}
+
+    callees = []
+    visited = set()
+
+    def find_callees(func, current_depth):
+        if depth and current_depth >= depth:
+            return
+        if str(func.getEntryPoint()) in visited:
+            return
+
+        visited.add(str(func.getEntryPoint()))
+
+        from ghidra.program.model.symbol import RefType
+        refs = reference_manager.getReferencesFrom(func.getEntryPoint())
+
+        for ref in refs:
+            if ref.getReferenceType().isCall():
+                to_addr = ref.getToAddress()
+                callee_func = function_manager.getFunctionAt(to_addr)
+                if callee_func:
+                    callee_info = {
+                        "name": callee_func.getName(),
+                        "address": str(callee_func.getEntryPoint()),
+                        "call_site": str(ref.getFromAddress()),
+                        "depth": current_depth
+                    }
+                    callees.append(callee_info)
+
+                    if depth is None or current_depth + 1 < depth:
+                        find_callees(callee_func, current_depth + 1)
+
+    find_callees(target_func, 0)
+
+    return {"function": function_name, "callees": callees, "count": len(callees)}
+
+def export_graph(export_format):
+    """Export call graph in specified format."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    graph_data = get_call_graph(None)
+    if "error" in graph_data:
+        return graph_data
+
+    if export_format == "json":
+        return graph_data
+    elif export_format == "dot":
+        lines = ["digraph CallGraph {"]
+        lines.append('  rankdir=LR;')
+        lines.append('  node [shape=box];')
+
+        for node in graph_data["nodes"]:
+            node_id = node["id"].replace(":", "_")
+            label = node["name"]
+            lines.append('  "{}" [label="{}"];'.format(node_id, label))
+
+        for edge in graph_data["edges"]:
+            from_id = edge["from"].replace(":", "_")
+            to_id = edge["to"].replace(":", "_")
+            lines.append('  "{}" -> "{}";'.format(from_id, to_id))
+
+        lines.append("}")
+        return {"format": "dot", "output": "\n".join(lines)}
+    else:
+        return {"error": "Unsupported format: " + export_format}
+
+if __name__ == "__main__":
+    try:
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "calls":
+            limit = int(args[1]) if len(args) > 1 and args[1] else None
+            result = get_call_graph(limit)
+        elif command == "callers":
+            func_name = args[1] if len(args) > 1 else None
+            depth = int(args[2]) if len(args) > 2 and args[2] else None
+            result = get_callers(func_name, depth)
+        elif command == "callees":
+            func_name = args[1] if len(args) > 1 else None
+            depth = int(args[2]) if len(args) > 2 and args[2] else None
+            result = get_callees(func_name, depth)
+        elif command == "export":
+            fmt = args[1] if len(args) > 1 else "json"
+            result = export_graph(fmt)
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/patch.py b/src/ghidra/scripts/patch.py
new file mode 100644
index 0000000..8783a6a
--- /dev/null
+++ b/src/ghidra/scripts/patch.py
@@ -0,0 +1,134 @@
+# Patch operations script
+# @category CLI
+
+import sys
+import json
+
+def patch_bytes(address_str, hex_data):
+    """Patch bytes at the specified address."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        addr = currentProgram.getAddressFactory().getAddress(address_str)
+        if addr is None:
+            return {"error": "Invalid address: " + address_str}
+
+        hex_clean = hex_data.replace("0x", "").replace(" ", "")
+
+        byte_array = []
+        for i in range(0, len(hex_clean), 2):
+            byte_val = int(hex_clean[i:i+2], 16)
+            if byte_val > 127:
+                byte_val = byte_val - 256
+            byte_array.append(byte_val)
+
+        from java.lang import Byte
+        patch_bytes = [Byte(b) for b in byte_array]
+
+        memory = currentProgram.getMemory()
+        memory.setBytes(addr, patch_bytes)
+
+        return {
+            "status": "patched",
+            "address": str(addr),
+            "bytes": len(patch_bytes)
+        }
+    except Exception as e:
+        return {"error": "Failed to patch bytes: " + str(e)}
+
+def patch_nop(address_str):
+    """NOP out instruction at the specified address."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        addr = currentProgram.getAddressFactory().getAddress(address_str)
+        if addr is None:
+            return {"error": "Invalid address: " + address_str}
+
+        listing = currentProgram.getListing()
+        instruction = listing.getInstructionAt(addr)
+
+        if instruction is None:
+            return {"error": "No instruction at address: " + address_str}
+
+        instr_length = instruction.getLength()
+
+        processor = currentProgram.getLanguage().getProcessor().toString()
+
+        if "x86" in processor.lower():
+            nop_byte = 0x90
+        elif "ARM" in processor or "aarch" in processor.lower():
+            nop_byte = 0x00
+        else:
+            nop_byte = 0x00
+
+        from java.lang import Byte
+        nop_bytes = [Byte(nop_byte) for _ in range(instr_length)]
+
+        memory = currentProgram.getMemory()
+        memory.setBytes(addr, nop_bytes)
+
+        return {
+            "status": "nopped",
+            "address": str(addr),
+            "bytes": instr_length
+        }
+    except Exception as e:
+        return {"error": "Failed to NOP instruction: " + str(e)}
+
+def export_binary(output_path):
+    """Export the patched binary."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        from ghidra.app.util.exporter import BinaryExporter
+        from java.io import File
+
+        exporter = BinaryExporter()
+        output_file = File(output_path)
+
+        exporter.export(output_file, currentProgram, None, monitor)
+
+        return {
+            "status": "exported",
+            "output": output_path
+        }
+    except Exception as e:
+        return {"error": "Failed to export binary: " + str(e)}
+
+# Alias for bridge.py compatibility
+def export_patches(output_path):
+    """Export patches (alias for export_binary)."""
+    return export_binary(output_path)
+
+if __name__ == "__main__":
+    try:
+        args = getScriptArgs()
+
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "patch_bytes":
+            result = patch_bytes(args[1] if len(args) > 1 else "", args[2] if len(args) > 2 else "")
+        elif command == "patch_nop":
+            result = patch_nop(args[1] if len(args) > 1 else "")
+        elif command == "patch_export":
+            result = export_binary(args[1] if len(args) > 1 else "")
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/program.py b/src/ghidra/scripts/program.py
new file mode 100644
index 0000000..629d458
--- /dev/null
+++ b/src/ghidra/scripts/program.py
@@ -0,0 +1,115 @@
+# Program operations script
+# @category CLI
+
+import sys
+import json
+
+def close_program():
+    """Close the current program."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    program_name = currentProgram.getName()
+    state.getTool().closeProgram(currentProgram, False)
+
+    return {"status": "closed", "program": program_name}
+
+def delete_program(program_name):
+    """Delete a program from the project."""
+    project = state.getProject()
+    if project is None:
+        return {"error": "No project open"}
+
+    project_data = project.getProjectData()
+
+    try:
+        program_file = project_data.getFile(program_name)
+        if program_file is None:
+            return {"error": "Program not found: " + program_name}
+
+        project_data.deleteFile(program_name)
+        return {"status": "deleted", "program": program_name}
+    except Exception as e:
+        return {"error": "Failed to delete program: " + str(e)}
+
+def get_program_info():
+    """Get current program metadata."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    info = {
+        "name": currentProgram.getName(),
+        "path": currentProgram.getExecutablePath(),
+        "format": currentProgram.getExecutableFormat(),
+        "processor": str(currentProgram.getLanguage().getProcessor()),
+        "language": str(currentProgram.getLanguage()),
+        "compiler": currentProgram.getCompiler() if currentProgram.getCompiler() else None,
+        "image_base": str(currentProgram.getImageBase()),
+        "min_address": str(currentProgram.getMinAddress()),
+        "max_address": str(currentProgram.getMaxAddress()),
+        "creation_date": str(currentProgram.getCreationDate())
+    }
+
+    return info
+
+def export_program(export_format, output_path):
+    """Export program to specified format."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    from ghidra.app.util.exporter import Exporter
+    from ghidra.framework.model import DomainFile
+    from java.io import File
+
+    if export_format == "json":
+        data = get_program_info()
+
+        function_manager = currentProgram.getFunctionManager()
+        functions = []
+        for func in function_manager.getFunctions(True):
+            functions.append({
+                "name": func.getName(),
+                "address": str(func.getEntryPoint()),
+                "size": func.getBody().getNumAddresses()
+            })
+        data["functions"] = functions
+
+        if output_path:
+            with open(output_path, 'w') as f:
+                json.dump(data, f, indent=2)
+            return {"status": "exported", "format": "json", "output": output_path}
+        else:
+            return data
+    else:
+        return {"error": "Unsupported export format: " + export_format}
+
+if __name__ == "__main__":
+    try:
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "close":
+            result = close_program()
+        elif command == "delete":
+            result = delete_program(args[1] if len(args) > 1 else None)
+        elif command == "info":
+            result = get_program_info()
+        elif command == "export":
+            fmt = args[1] if len(args) > 1 else "json"
+            output = args[2] if len(args) > 2 else None
+            result = export_program(fmt, output)
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/script_runner.py b/src/ghidra/scripts/script_runner.py
new file mode 100644
index 0000000..389e3fc
--- /dev/null
+++ b/src/ghidra/scripts/script_runner.py
@@ -0,0 +1,121 @@
+# Script execution operations
+# @category CLI
+
+import sys
+import json
+import os
+
+def run_script(script_path, script_args):
+    """Run a user script file."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        if not os.path.exists(script_path):
+            return {"error": "Script not found: " + script_path}
+
+        from ghidra.app.script import GhidraScriptUtil
+
+        script_info = GhidraScriptUtil.findScriptByName(os.path.basename(script_path))
+        if script_info is None:
+            return {"error": "Could not load script: " + script_path}
+
+        result = runScript(script_path, script_args if script_args else [])
+
+        return {
+            "status": "executed",
+            "script": script_path,
+            "result": str(result) if result is not None else None
+        }
+    except Exception as e:
+        return {"error": "Failed to run script: " + str(e)}
+
+def exec_python(code):
+    """Execute inline Python code."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        local_vars = {
+            "currentProgram": currentProgram,
+            "currentAddress": currentAddress if 'currentAddress' in dir() else None,
+            "currentLocation": currentLocation if 'currentLocation' in dir() else None,
+            "state": state if 'state' in dir() else None
+        }
+
+        exec(code, globals(), local_vars)
+
+        output = local_vars.get("output", None)
+
+        return {
+            "status": "executed",
+            "output": str(output) if output is not None else "Code executed successfully"
+        }
+    except Exception as e:
+        return {"error": "Failed to execute Python code: " + str(e)}
+
+def exec_java(code):
+    """Execute inline Java code."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        return {"error": "Java execution not yet implemented"}
+    except Exception as e:
+        return {"error": "Failed to execute Java code: " + str(e)}
+
+def list_scripts():
+    """List available scripts."""
+    try:
+        from ghidra.app.script import GhidraScriptUtil
+
+        script_infos = GhidraScriptUtil.getScriptSourceDirectories()
+        scripts = []
+
+        for script_dir in script_infos:
+            script_path = str(script_dir)
+            if os.path.exists(script_path) and os.path.isdir(script_path):
+                for filename in os.listdir(script_path):
+                    if filename.endswith('.py') or filename.endswith('.java'):
+                        scripts.append({
+                            "name": filename,
+                            "path": os.path.join(script_path, filename),
+                            "type": "python" if filename.endswith('.py') else "java"
+                        })
+
+        return {"scripts": scripts, "count": len(scripts)}
+    except Exception as e:
+        return {"error": "Failed to list scripts: " + str(e)}
+
+if __name__ == "__main__":
+    try:
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "run":
+            script_path = args[1] if len(args) > 1 else None
+            script_args = args[2:] if len(args) > 2 else []
+            result = run_script(script_path, script_args)
+        elif command == "python":
+            code = args[1] if len(args) > 1 else None
+            result = exec_python(code)
+        elif command == "java":
+            code = args[1] if len(args) > 1 else None
+            result = exec_java(code)
+        elif command == "list":
+            result = list_scripts()
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/stats.py b/src/ghidra/scripts/stats.py
new file mode 100644
index 0000000..2bccda9
--- /dev/null
+++ b/src/ghidra/scripts/stats.py
@@ -0,0 +1,98 @@
+# Program statistics script
+# @category CLI
+
+import sys
+import json
+
+def get_stats():
+    """Gather comprehensive program statistics."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        func_manager = currentProgram.getFunctionManager()
+        symbol_table = currentProgram.getSymbolTable()
+        memory = currentProgram.getMemory()
+        data_type_manager = currentProgram.getDataTypeManager()
+        listing = currentProgram.getListing()
+
+        function_count = func_manager.getFunctionCount()
+
+        symbol_count = 0
+        symbol_iter = symbol_table.getAllSymbols(True)
+        while symbol_iter.hasNext():
+            symbol_iter.next()
+            symbol_count += 1
+
+        string_count = 0
+        data_iter = listing.getDefinedData(True)
+        while data_iter.hasNext():
+            data = data_iter.next()
+            if data.hasStringValue():
+                string_count += 1
+
+        memory_size = 0
+        for block in memory.getBlocks():
+            memory_size += block.getSize()
+
+        section_count = len(list(memory.getBlocks()))
+
+        import_count = 0
+        export_count = 0
+        for symbol in symbol_table.getExternalSymbols():
+            import_count += 1
+
+        export_iter = symbol_table.getExternalEntryPointIterator()
+        while export_iter.hasNext():
+            export_iter.next()
+            export_count += 1
+
+        data_type_count = data_type_manager.getDataTypeCount(False)
+
+        instruction_count = 0
+        code_unit_iter = listing.getInstructions(True)
+        while code_unit_iter.hasNext():
+            code_unit_iter.next()
+            instruction_count += 1
+
+        stats = {
+            "functions": function_count,
+            "symbols": symbol_count,
+            "strings": string_count,
+            "imports": import_count,
+            "exports": export_count,
+            "memory_size": memory_size,
+            "sections": section_count,
+            "data_types": data_type_count,
+            "instructions": instruction_count,
+            "program_name": currentProgram.getName(),
+            "executable_format": currentProgram.getExecutableFormat(),
+            "compiler": str(currentProgram.getCompiler()) if currentProgram.getCompiler() else "Unknown"
+        }
+
+        return {"stats": stats}
+    except Exception as e:
+        return {"error": "Failed to gather statistics: " + str(e)}
+
+if __name__ == "__main__":
+    try:
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "stats":
+            result = get_stats()
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/symbols.py b/src/ghidra/scripts/symbols.py
new file mode 100644
index 0000000..b96bf69
--- /dev/null
+++ b/src/ghidra/scripts/symbols.py
@@ -0,0 +1,161 @@
+# Symbol operations script
+# @category CLI
+
+import sys
+import json
+
+def list_symbols(name_filter):
+    """List all symbols in the program."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    symbol_table = currentProgram.getSymbolTable()
+    symbols = []
+
+    for symbol in symbol_table.getAllSymbols(True):
+        name = symbol.getName()
+
+        if name_filter and name_filter.lower() not in name.lower():
+            continue
+
+        symbol_data = {
+            "name": name,
+            "address": str(symbol.getAddress()),
+            "type": str(symbol.getSymbolType()),
+            "source": str(symbol.getSource()),
+            "is_primary": symbol.isPrimary()
+        }
+        symbols.append(symbol_data)
+
+    return {"symbols": symbols, "count": len(symbols)}
+
+def get_symbol(address_or_name):
+    """Get symbol at specific address or by name."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    symbol_table = currentProgram.getSymbolTable()
+
+    if address_or_name.startswith("0x") or all(c in "0123456789abcdefABCDEF" for c in address_or_name):
+        try:
+            addr = currentProgram.getAddressFactory().getAddress(address_or_name)
+            if addr is None:
+                return {"error": "Invalid address: " + address_or_name}
+
+            symbols_at_addr = symbol_table.getSymbols(addr)
+            if not symbols_at_addr:
+                return {"error": "No symbol at address: " + address_or_name}
+
+            result_symbols = []
+            for symbol in symbols_at_addr:
+                result_symbols.append({
+                    "name": symbol.getName(),
+                    "address": str(symbol.getAddress()),
+                    "type": str(symbol.getSymbolType()),
+                    "source": str(symbol.getSource())
+                })
+            return {"symbols": result_symbols}
+        except Exception as e:
+            return {"error": "Failed to get symbol: " + str(e)}
+    else:
+        symbols = symbol_table.getSymbols(address_or_name)
+        if not symbols or len(symbols) == 0:
+            return {"error": "Symbol not found: " + address_or_name}
+
+        result_symbols = []
+        for symbol in symbols:
+            result_symbols.append({
+                "name": symbol.getName(),
+                "address": str(symbol.getAddress()),
+                "type": str(symbol.getSymbolType()),
+                "source": str(symbol.getSource())
+            })
+        return {"symbols": result_symbols}
+
+def create_symbol(address_str, name):
+    """Create a new symbol."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        addr = currentProgram.getAddressFactory().getAddress(address_str)
+        if addr is None:
+            return {"error": "Invalid address: " + address_str}
+
+        symbol_table = currentProgram.getSymbolTable()
+        from ghidra.program.model.symbol import SourceType
+
+        symbol_table.createLabel(addr, name, SourceType.USER_DEFINED)
+
+        return {"status": "created", "address": address_str, "name": name}
+    except Exception as e:
+        return {"error": "Failed to create symbol: " + str(e)}
+
+def delete_symbol(name):
+    """Delete a symbol by name."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        symbol_table = currentProgram.getSymbolTable()
+        symbols = symbol_table.getSymbols(name)
+
+        if not symbols or len(symbols) == 0:
+            return {"error": "Symbol not found: " + name}
+
+        for symbol in symbols:
+            symbol.delete()
+
+        return {"status": "deleted", "name": name}
+    except Exception as e:
+        return {"error": "Failed to delete symbol: " + str(e)}
+
+def rename_symbol(old_name, new_name):
+    """Rename a symbol."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        symbol_table = currentProgram.getSymbolTable()
+        symbols = symbol_table.getSymbols(old_name)
+
+        if not symbols or len(symbols) == 0:
+            return {"error": "Symbol not found: " + old_name}
+
+        for symbol in symbols:
+            symbol.setName(new_name, symbol.getSource())
+
+        return {"status": "renamed", "old_name": old_name, "new_name": new_name}
+    except Exception as e:
+        return {"error": "Failed to rename symbol: " + str(e)}
+
+if __name__ == "__main__":
+    try:
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "list":
+            result = list_symbols(args[1] if len(args) > 1 else None)
+        elif command == "get":
+            result = get_symbol(args[1] if len(args) > 1 else None)
+        elif command == "create":
+            result = create_symbol(args[1] if len(args) > 1 else None, args[2] if len(args) > 2 else None)
+        elif command == "delete":
+            result = delete_symbol(args[1] if len(args) > 1 else None)
+        elif command == "rename":
+            result = rename_symbol(args[1] if len(args) > 1 else None, args[2] if len(args) > 2 else None)
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ghidra/scripts/types.py b/src/ghidra/scripts/types.py
new file mode 100644
index 0000000..302bb9a
--- /dev/null
+++ b/src/ghidra/scripts/types.py
@@ -0,0 +1,137 @@
+# Type operations script
+# @category CLI
+
+import sys
+import json
+
+def list_types():
+    """List all defined types in the program."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    data_type_manager = currentProgram.getDataTypeManager()
+    types = []
+
+    for data_type in data_type_manager.getAllDataTypes():
+        type_data = {
+            "name": data_type.getName(),
+            "path": data_type.getPathName(),
+            "category": data_type.getCategoryPath().toString(),
+            "size": data_type.getLength()
+        }
+        types.append(type_data)
+
+    return {"types": types, "count": len(types)}
+
+def get_type(type_name):
+    """Get type definition by name."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    data_type_manager = currentProgram.getDataTypeManager()
+
+    data_type = data_type_manager.getDataType(type_name)
+    if data_type is None:
+        for dt in data_type_manager.getAllDataTypes():
+            if dt.getName() == type_name:
+                data_type = dt
+                break
+
+    if data_type is None:
+        return {"error": "Type not found: " + type_name}
+
+    type_info = {
+        "name": data_type.getName(),
+        "path": data_type.getPathName(),
+        "category": data_type.getCategoryPath().toString(),
+        "size": data_type.getLength(),
+        "description": data_type.getDescription()
+    }
+
+    from ghidra.program.model.data import Structure, Union
+    if isinstance(data_type, Structure) or isinstance(data_type, Union):
+        components = []
+        for component in data_type.getComponents():
+            components.append({
+                "name": component.getFieldName(),
+                "type": component.getDataType().getName(),
+                "offset": component.getOffset(),
+                "size": component.getLength()
+            })
+        type_info["components"] = components
+
+    return type_info
+
+def create_type(type_name):
+    """Create a new empty struct type."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        from ghidra.program.model.data import StructureDataType
+        data_type_manager = currentProgram.getDataTypeManager()
+
+        new_struct = StructureDataType(type_name, 0)
+        data_type_manager.addDataType(new_struct, None)
+
+        return {"status": "created", "name": type_name}
+    except Exception as e:
+        return {"error": "Failed to create type: " + str(e)}
+
+def apply_type(address_str, type_name):
+    """Apply a type to a specific address."""
+    if currentProgram is None:
+        return {"error": "No program loaded"}
+
+    try:
+        addr = currentProgram.getAddressFactory().getAddress(address_str)
+        if addr is None:
+            return {"error": "Invalid address: " + address_str}
+
+        data_type_manager = currentProgram.getDataTypeManager()
+        data_type = data_type_manager.getDataType(type_name)
+
+        if data_type is None:
+            for dt in data_type_manager.getAllDataTypes():
+                if dt.getName() == type_name:
+                    data_type = dt
+                    break
+
+        if data_type is None:
+            return {"error": "Type not found: " + type_name}
+
+        listing = currentProgram.getListing()
+        listing.createData(addr, data_type)
+
+        return {"status": "applied", "address": address_str, "type": type_name}
+    except Exception as e:
+        return {"error": "Failed to apply type: " + str(e)}
+
+if __name__ == "__main__":
+    try:
+        if len(args) < 1:
+            print("---GHIDRA_CLI_START---")
+            print(json.dumps({"error": "No command specified"}))
+            print("---GHIDRA_CLI_END---")
+            sys.exit(1)
+
+        command = args[0]
+
+        if command == "list":
+            result = list_types()
+        elif command == "get":
+            result = get_type(args[1] if len(args) > 1 else None)
+        elif command == "create":
+            result = create_type(args[1] if len(args) > 1 else None)
+        elif command == "apply":
+            result = apply_type(args[1] if len(args) > 1 else None, args[2] if len(args) > 2 else None)
+        else:
+            result = {"error": "Unknown command: " + command}
+
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps(result))
+        print("---GHIDRA_CLI_END---")
+    except Exception as e:
+        print("---GHIDRA_CLI_START---")
+        print(json.dumps({"error": str(e)}))
+        print("---GHIDRA_CLI_END---")
diff --git a/src/ipc/client.rs b/src/ipc/client.rs
index b951836..f875920 100644
--- a/src/ipc/client.rs
+++ b/src/ipc/client.rs
@@ -147,6 +147,11 @@ impl DaemonClient {
     pub async fn xrefs_from(&mut self, address: String) -> Result<serde_json::Value> {
         self.send_command(Command::XRefsFrom { address }).await
     }
+
+    /// Execute a CLI command through the daemon (takes pre-serialized JSON).
+    pub async fn execute_cli_json(&mut self, command_json: String) -> Result<serde_json::Value> {
+        self.send_command(Command::ExecuteCli { command_json }).await
+    }
 }
 
 /// Check if daemon is running (without establishing a full connection).
diff --git a/src/ipc/protocol.rs b/src/ipc/protocol.rs
index 18b418f..1ab43d4 100644
--- a/src/ipc/protocol.rs
+++ b/src/ipc/protocol.rs
@@ -97,7 +97,7 @@ pub enum Command {
     /// List imports
     ListImports,
 
-    /// List exports  
+    /// List exports
     ListExports,
 
     /// Get memory map
@@ -124,6 +124,13 @@ pub enum Command {
 
     /// Shutdown the daemon
     Shutdown,
+
+    // === Generic CLI Command Forwarding ===
+    /// Execute a CLI command through the daemon's queue
+    ExecuteCli {
+        /// The serialized CLI command
+        command_json: String,
+    },
 }
 
 #[cfg(test)]
diff --git a/src/main.rs b/src/main.rs
index b529aed..f248707 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -99,6 +99,16 @@ fn requires_daemon(command: &Commands) -> bool {
             | Commands::Dump(_)
             | Commands::Summary(_)
             | Commands::XRef(_)
+            | Commands::Symbol(_)
+            | Commands::Type(_)
+            | Commands::Comment(_)
+            | Commands::Graph(_)
+            | Commands::Find(_)
+            | Commands::Diff(_)
+            | Commands::Patch(_)
+            | Commands::Script(_)
+            | Commands::Disasm(_)
+            | Commands::Stats(_)
     )
 }
 
@@ -195,6 +205,21 @@ async fn execute_via_daemon(
                 XRefCommands::List(_) => anyhow::bail!("XRef list not yet supported via daemon"),
             }
         }
+        // New commands - forward through ExecuteCli
+        Commands::Symbol(_)
+        | Commands::Type(_)
+        | Commands::Comment(_)
+        | Commands::Graph(_)
+        | Commands::Find(_)
+        | Commands::Diff(_)
+        | Commands::Patch(_)
+        | Commands::Script(_)
+        | Commands::Disasm(_)
+        | Commands::Stats(_) => {
+            let command_json = serde_json::to_string(command)
+                .map_err(|e| anyhow::anyhow!("Failed to serialize command: {}", e))?;
+            client.execute_cli_json(command_json).await?
+        }
         _ => anyhow::bail!("Command not supported via daemon"),
     };
 
diff --git a/tests/batch_tests.rs b/tests/batch_tests.rs
new file mode 100644
index 0000000..9442514
--- /dev/null
+++ b/tests/batch_tests.rs
@@ -0,0 +1,178 @@
+//! Tests for batch operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+use std::fs;
+use std::path::PathBuf;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "batch-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+fn create_batch_file(content: &str) -> PathBuf {
+    let temp_dir = std::env::temp_dir();
+    let batch_file = temp_dir.join(format!("ghidra_batch_{}.txt", std::process::id()));
+    fs::write(&batch_file, content).expect("Failed to write batch file");
+    batch_file
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_batch_multiple_queries() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    let batch_content = r#"
+# Test batch file
+query --address 0x100000
+query --function main
+"#;
+
+    let batch_file = create_batch_file(batch_content);
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("batch")
+        .arg(batch_file.to_str().unwrap())
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("commands_parsed"))
+        .stdout(predicate::str::contains("results"));
+
+    fs::remove_file(batch_file).ok();
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_batch_empty_file() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    let batch_content = r#"
+# Only comments
+
+
+# More comments
+"#;
+
+    let batch_file = create_batch_file(batch_content);
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("batch")
+        .arg(batch_file.to_str().unwrap())
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("commands_parsed"));
+
+    fs::remove_file(batch_file).ok();
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_batch_with_comments() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    let batch_content = r#"
+# Query main function
+query --function main
+# Query by address
+query --address 0x100000
+# Another comment
+"#;
+
+    let batch_file = create_batch_file(batch_content);
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("batch")
+        .arg(batch_file.to_str().unwrap())
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("commands_parsed"))
+        .stdout(predicate::str::contains("2"));
+
+    fs::remove_file(batch_file).ok();
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_batch_invalid_file() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("batch")
+        .arg("/nonexistent/batch/file.txt")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("not found"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_batch_with_invalid_command() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    let batch_content = r#"
+query --function main
+invalid-command --arg value
+query --address 0x100000
+"#;
+
+    let batch_file = create_batch_file(batch_content);
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("batch")
+        .arg(batch_file.to_str().unwrap())
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("commands_parsed"))
+        .stdout(predicate::str::contains("3"));
+
+    fs::remove_file(batch_file).ok();
+    drop(harness);
+}
diff --git a/tests/comment_tests.rs b/tests/comment_tests.rs
new file mode 100644
index 0000000..2fd81d8
--- /dev/null
+++ b/tests/comment_tests.rs
@@ -0,0 +1,118 @@
+//! Tests for comment operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "comment-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_comment_set_and_get() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("comment")
+        .arg("set")
+        .arg("0x1000")
+        .arg("test comment")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("comment")
+        .arg("get")
+        .arg("0x1000")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("test comment"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_comment_list() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("comment")
+        .arg("set")
+        .arg("0x2000")
+        .arg("another comment")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("comment")
+        .arg("list")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("comments"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_comment_delete() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("comment")
+        .arg("set")
+        .arg("0x3000")
+        .arg("to be deleted")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("comment")
+        .arg("delete")
+        .arg("0x3000")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    drop(harness);
+}
diff --git a/tests/daemon_tests.rs b/tests/daemon_tests.rs
index 5765cee..ecff73b 100644
--- a/tests/daemon_tests.rs
+++ b/tests/daemon_tests.rs
@@ -13,6 +13,7 @@ const TEST_PROGRAM: &str = "sample_binary";
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_daemon_start() {
 
     ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
@@ -33,6 +34,7 @@ fn test_daemon_start() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_daemon_status() {
 
     ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
@@ -54,6 +56,7 @@ fn test_daemon_status() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_daemon_ping() {
 
     ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
@@ -74,6 +77,7 @@ fn test_daemon_ping() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_daemon_clear_cache() {
 
     ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
@@ -94,6 +98,7 @@ fn test_daemon_clear_cache() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_daemon_lifecycle() {
 
     ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
diff --git a/tests/diff_tests.rs b/tests/diff_tests.rs
new file mode 100644
index 0000000..47ad2ea
--- /dev/null
+++ b/tests/diff_tests.rs
@@ -0,0 +1,60 @@
+//! Tests for diff operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "diff-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_diff_programs() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("diff")
+        .arg("programs")
+        .arg(TEST_PROGRAM)
+        .arg(TEST_PROGRAM)
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("program1"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore]
+fn test_diff_functions() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("diff")
+        .arg("functions")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("CLI update"));
+
+    drop(harness);
+}
diff --git a/tests/disasm_tests.rs b/tests/disasm_tests.rs
new file mode 100644
index 0000000..c7d6f64
--- /dev/null
+++ b/tests/disasm_tests.rs
@@ -0,0 +1,128 @@
+//! Tests for disassembly operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "disasm-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_disasm_at_main() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("disasm")
+        .arg("0x101040")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("results"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_disasm_with_instruction_limit() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("disasm")
+        .arg("0x101040")
+        .arg("--instructions")
+        .arg("10")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("results"))
+        .stdout(predicate::str::contains("mnemonic"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_disasm_at_data_section() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("disasm")
+        .arg("0x104000")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert();
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_disasm_invalid_address() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("disasm")
+        .arg("0xFFFFFFFFFFFF")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert();
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_disasm_small_count() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("disasm")
+        .arg("0x101040")
+        .arg("--instructions")
+        .arg("3")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("results"));
+
+    drop(harness);
+}
diff --git a/tests/find_tests.rs b/tests/find_tests.rs
new file mode 100644
index 0000000..d2e7bcf
--- /dev/null
+++ b/tests/find_tests.rs
@@ -0,0 +1,201 @@
+//! Tests for find/search operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "find-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_find_string() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("find")
+        .arg("string")
+        .arg("test")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("results"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_find_bytes() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("find")
+        .arg("bytes")
+        .arg("4883ec08")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("results"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_find_function() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("find")
+        .arg("function")
+        .arg("main")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("results"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_find_function_glob() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("find")
+        .arg("function")
+        .arg("m*")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("results"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_find_calls() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("find")
+        .arg("calls")
+        .arg("printf")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_find_crypto() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("find")
+        .arg("crypto")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("results"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_find_interesting() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("find")
+        .arg("interesting")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("results"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_find_string_no_matches() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("find")
+        .arg("string")
+        .arg("nonexistent_string_xyz123")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("results"));
+
+    drop(harness);
+}
diff --git a/tests/graph_tests.rs b/tests/graph_tests.rs
new file mode 100644
index 0000000..808ce5c
--- /dev/null
+++ b/tests/graph_tests.rs
@@ -0,0 +1,108 @@
+//! Tests for graph operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "graph-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_graph_calls() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("graph")
+        .arg("calls")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("nodes"))
+        .stdout(predicate::str::contains("edges"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_graph_callers() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("graph")
+        .arg("callers")
+        .arg("main")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("callers"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_graph_callees() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("graph")
+        .arg("callees")
+        .arg("main")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("callees"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_graph_export_dot() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("graph")
+        .arg("export")
+        .arg("dot")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("digraph"));
+
+    drop(harness);
+}
diff --git a/tests/patch_tests.rs b/tests/patch_tests.rs
new file mode 100644
index 0000000..b990700
--- /dev/null
+++ b/tests/patch_tests.rs
@@ -0,0 +1,136 @@
+//! Tests for patch operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "patch-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_patch_bytes() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("patch")
+        .arg("bytes")
+        .arg("0x101000")
+        .arg("90909090")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("patched").or(predicate::str::contains("status")));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_patch_nop() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("patch")
+        .arg("nop")
+        .arg("0x101000")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("nopped").or(predicate::str::contains("status")));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_patch_export() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    let output_path = format!("/tmp/{}_patched.bin", TEST_PROJECT);
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("patch")
+        .arg("export")
+        .arg("--output")
+        .arg(&output_path)
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("exported").or(predicate::str::contains("status")));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_patch_at_function_boundary() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("patch")
+        .arg("bytes")
+        .arg("0x101000")
+        .arg("c3")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_patch_invalid_address() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("patch")
+        .arg("bytes")
+        .arg("0xffffffff")
+        .arg("90")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .failure();
+
+    drop(harness);
+}
diff --git a/tests/program_tests.rs b/tests/program_tests.rs
new file mode 100644
index 0000000..16c0920
--- /dev/null
+++ b/tests/program_tests.rs
@@ -0,0 +1,102 @@
+//! Tests for program operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "program-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_program_info() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("program")
+        .arg("info")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("name"))
+        .stdout(predicate::str::contains("format"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_program_export_json() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("program")
+        .arg("export")
+        .arg("json")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("functions"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_program_close() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("program")
+        .arg("close")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_program_info_no_program() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("program")
+        .arg("info")
+        .assert()
+        .failure();
+
+    drop(harness);
+}
diff --git a/tests/project_tests.rs b/tests/project_tests.rs
index dced1ce..e829e13 100644
--- a/tests/project_tests.rs
+++ b/tests/project_tests.rs
@@ -13,6 +13,7 @@ fn unique_project_name(prefix: &str) -> String {
 }
 
 #[test]
+#[ignore] // Requires Ghidra installation
 fn test_project_create() {
     let project = unique_project_name("create");
 
@@ -36,6 +37,7 @@ fn test_project_create() {
 }
 
 #[test]
+#[ignore] // Requires Ghidra installation
 fn test_project_list() {
     Command::cargo_bin("ghidra")
         .unwrap()
@@ -46,6 +48,7 @@ fn test_project_list() {
 }
 
 #[test]
+#[ignore] // Requires Ghidra installation
 fn test_project_info() {
     let project = unique_project_name("info");
 
@@ -76,6 +79,7 @@ fn test_project_info() {
 }
 
 #[test]
+#[ignore] // Requires Ghidra installation
 fn test_project_lifecycle() {
     let project = unique_project_name("lifecycle");
 
@@ -106,6 +110,7 @@ fn test_project_lifecycle() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_import_binary() {
     let project = unique_project_name("import");
     let binary = common::fixture_binary();
@@ -134,6 +139,7 @@ fn test_import_binary() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_analyze_program() {
     let project = unique_project_name("analyze");
     let binary = common::fixture_binary();
diff --git a/tests/query_tests.rs b/tests/query_tests.rs
index 471537e..df2fcd3 100644
--- a/tests/query_tests.rs
+++ b/tests/query_tests.rs
@@ -19,6 +19,7 @@ static HARNESS: Lazy<DaemonTestHarness> = Lazy::new(|| {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_function_list() {
     let harness = &*HARNESS;
 
@@ -44,6 +45,7 @@ fn test_function_list() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_function_list_limit() {
     let harness = &*HARNESS;
 
@@ -64,6 +66,7 @@ fn test_function_list_limit() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_function_list_filter() {
     let harness = &*HARNESS;
 
@@ -85,6 +88,7 @@ fn test_function_list_filter() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_strings_list() {
     let harness = &*HARNESS;
 
@@ -106,6 +110,7 @@ fn test_strings_list() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_memory_map() {
     let harness = &*HARNESS;
 
@@ -125,6 +130,7 @@ fn test_memory_map() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_summary() {
     let harness = &*HARNESS;
 
@@ -143,6 +149,7 @@ fn test_summary() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_decompile_by_name() {
     let harness = &*HARNESS;
 
@@ -162,6 +169,7 @@ fn test_decompile_by_name() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_decompile_by_address() {
     let harness = &*HARNESS;
 
@@ -205,6 +213,7 @@ fn test_decompile_by_address() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_xref_to() {
     let harness = &*HARNESS;
 
@@ -249,6 +258,7 @@ fn test_xref_to() {
 
 #[test]
 #[serial]
+#[ignore] // Requires Ghidra installation
 fn test_xref_from() {
     let harness = &*HARNESS;
 
diff --git a/tests/script_tests.rs b/tests/script_tests.rs
new file mode 100644
index 0000000..059debd
--- /dev/null
+++ b/tests/script_tests.rs
@@ -0,0 +1,135 @@
+//! Tests for script execution operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+use std::fs;
+use std::path::PathBuf;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "script-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+fn get_test_script_path() -> PathBuf {
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("tests");
+    path.push("fixtures");
+    path.push("test_script.py");
+    path
+}
+
+fn create_test_script() -> PathBuf {
+    let script_path = get_test_script_path();
+
+    fs::create_dir_all(script_path.parent().unwrap()).ok();
+
+    let script_content = r#"# Test script
+# @category Test
+
+print("Test script executed")
+"#;
+
+    fs::write(&script_path, script_content).expect("Failed to write test script");
+    script_path
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_script_list() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("script")
+        .arg("list")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("scripts"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_script_run() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let script_path = create_test_script();
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("script")
+        .arg("run")
+        .arg(script_path.to_str().unwrap())
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("executed"));
+
+    drop(harness);
+
+    fs::remove_file(script_path).ok();
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_script_python_inline() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("script")
+        .arg("python")
+        .arg("output = 'Hello from Python'")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("executed"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_script_run_nonexistent() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("script")
+        .arg("run")
+        .arg("/nonexistent/script.py")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .failure();
+
+    drop(harness);
+}
diff --git a/tests/stats_tests.rs b/tests/stats_tests.rs
new file mode 100644
index 0000000..30d47df
--- /dev/null
+++ b/tests/stats_tests.rs
@@ -0,0 +1,93 @@
+//! Tests for stats command.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "stats-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_stats_normal() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("stats")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("stats"))
+        .stdout(predicate::str::contains("functions"))
+        .stdout(predicate::str::contains("symbols"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_stats_has_all_fields() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("stats")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("functions"))
+        .stdout(predicate::str::contains("symbols"))
+        .stdout(predicate::str::contains("strings"))
+        .stdout(predicate::str::contains("imports"))
+        .stdout(predicate::str::contains("exports"))
+        .stdout(predicate::str::contains("memory_size"))
+        .stdout(predicate::str::contains("sections"))
+        .stdout(predicate::str::contains("data_types"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_stats_json_format() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    let output = Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("stats")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+
+    let output_str = String::from_utf8_lossy(&output);
+    assert!(serde_json::from_str::<serde_json::Value>(&output_str).is_ok(),
+            "Output should be valid JSON");
+
+    drop(harness);
+}
diff --git a/tests/symbol_tests.rs b/tests/symbol_tests.rs
new file mode 100644
index 0000000..2678686
--- /dev/null
+++ b/tests/symbol_tests.rs
@@ -0,0 +1,130 @@
+//! Tests for symbol operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "symbol-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_symbol_list() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("symbol")
+        .arg("list")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("symbols"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_symbol_create_and_get() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("symbol")
+        .arg("create")
+        .arg("0x1000")
+        .arg("test_symbol")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("symbol")
+        .arg("get")
+        .arg("test_symbol")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("test_symbol"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_symbol_rename() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("symbol")
+        .arg("create")
+        .arg("0x2000")
+        .arg("old_symbol")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("symbol")
+        .arg("rename")
+        .arg("old_symbol")
+        .arg("new_symbol")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_symbol_get_nonexistent() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("symbol")
+        .arg("get")
+        .arg("nonexistent_symbol_12345")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .failure();
+
+    drop(harness);
+}
diff --git a/tests/type_tests.rs b/tests/type_tests.rs
new file mode 100644
index 0000000..2094cc5
--- /dev/null
+++ b/tests/type_tests.rs
@@ -0,0 +1,129 @@
+//! Tests for type operations.
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use serial_test::serial;
+
+#[macro_use]
+mod common;
+use common::{ensure_test_project, DaemonTestHarness};
+
+const TEST_PROJECT: &str = "type-test";
+const TEST_PROGRAM: &str = "sample_binary";
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_type_list() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("type")
+        .arg("list")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("types"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_type_get_primitive() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("type")
+        .arg("get")
+        .arg("int")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("size"));
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_type_create() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("type")
+        .arg("create")
+        .arg("MyTestStruct")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_type_apply() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("type")
+        .arg("apply")
+        .arg("0x1000")
+        .arg("int")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .success();
+
+    drop(harness);
+}
+
+#[test]
+#[serial]
+#[ignore] // Requires Ghidra installation
+fn test_type_get_nonexistent() {
+    ensure_test_project(TEST_PROJECT, TEST_PROGRAM);
+
+    let harness = DaemonTestHarness::new(TEST_PROJECT, TEST_PROGRAM)
+        .expect("Failed to start daemon");
+
+    Command::cargo_bin("ghidra")
+        .unwrap()
+        .env("GHIDRA_CLI_SOCKET", harness.socket_path())
+        .arg("type")
+        .arg("get")
+        .arg("NonexistentType12345")
+        .arg("--program")
+        .arg(TEST_PROGRAM)
+        .assert()
+        .failure();
+
+    drop(harness);
+}
diff --git a/tests/unimplemented_tests.rs b/tests/unimplemented_tests.rs
index 485ebe9..02d82f7 100644
--- a/tests/unimplemented_tests.rs
+++ b/tests/unimplemented_tests.rs
@@ -1,86 +1,9 @@
-//! Tests for unimplemented commands to ensure graceful error messages.
+//! Tests for graceful error handling.
 //!
-//! These tests verify that unimplemented commands print a helpful message
-//! instead of crashing or panicking.
+//! Most commands are now implemented and require the daemon.
+//! This file is kept for documentation but has no active tests.
 //!
-//! NOTE: Current CLI outputs to stdout with exit 0. This should eventually
-//! be changed to stderr with exit 1 for proper error handling.
+//! To run integration tests that require Ghidra:
+//!   cargo test -- --ignored
 
-use assert_cmd::Command;
-use predicates::prelude::*;
-
-// Macro reduces boilerplate for unimplemented command tests.
-macro_rules! test_unimplemented {
-    ($name:ident, $($arg:expr),*) => {
-        #[test]
-        fn $name() {
-            Command::cargo_bin("ghidra").unwrap()
-                $(.arg($arg))*
-                .assert()
-                .success()  // CLI currently exits 0 for unimplemented
-                .stdout(predicate::str::contains("not yet implemented")
-                    .or(predicate::str::contains("Command not yet implemented")));
-        }
-    };
-}
-
-// Program commands (use --program flag)
-test_unimplemented!(test_program_close, "program", "close", "--program", "test");
-test_unimplemented!(test_program_delete, "program", "delete", "--program", "test");
-test_unimplemented!(test_program_info, "program", "info", "--program", "test");
-test_unimplemented!(test_program_export, "program", "export", "--program", "test", "json");
-
-// Symbol commands (use positional args)
-test_unimplemented!(test_symbol_list, "symbol", "list");
-test_unimplemented!(test_symbol_get, "symbol", "get", "0x1000");
-test_unimplemented!(test_symbol_create, "symbol", "create", "0x1000", "test_sym");
-test_unimplemented!(test_symbol_delete, "symbol", "delete", "test_sym");
-test_unimplemented!(test_symbol_rename, "symbol", "rename", "test_sym", "new_sym");
-
-// Type commands (use positional args)
-test_unimplemented!(test_type_list, "type", "list");
-test_unimplemented!(test_type_get, "type", "get", "int");
-test_unimplemented!(test_type_create, "type", "create", "my_struct");
-test_unimplemented!(test_type_apply, "type", "apply", "0x1000", "int");
-
-// Comment commands (use positional args)
-test_unimplemented!(test_comment_list, "comment", "list");
-test_unimplemented!(test_comment_get, "comment", "get", "0x1000");
-test_unimplemented!(test_comment_set, "comment", "set", "0x1000", "test");
-test_unimplemented!(test_comment_delete, "comment", "delete", "0x1000");
-
-// Find commands
-test_unimplemented!(test_find_string, "find", "string", "test");
-test_unimplemented!(test_find_bytes, "find", "bytes", "deadbeef");
-test_unimplemented!(test_find_function, "find", "function", "test");
-test_unimplemented!(test_find_calls, "find", "calls", "test");
-test_unimplemented!(test_find_crypto, "find", "crypto");
-test_unimplemented!(test_find_interesting, "find", "interesting");
-
-// Graph commands
-test_unimplemented!(test_graph_calls, "graph", "calls");
-test_unimplemented!(test_graph_callers, "graph", "callers", "main");
-test_unimplemented!(test_graph_callees, "graph", "callees", "main");
-test_unimplemented!(test_graph_export, "graph", "export", "dot");
-
-// Diff commands
-test_unimplemented!(test_diff_programs, "diff", "programs", "prog1", "prog2");
-test_unimplemented!(test_diff_functions, "diff", "functions");
-
-// Patch commands
-test_unimplemented!(test_patch_bytes, "patch", "bytes", "0x1000", "deadbeef");
-test_unimplemented!(test_patch_nop, "patch", "nop", "0x1000");
-test_unimplemented!(test_patch_export, "patch", "export", "--output", "test.bin");
-
-// Script commands
-test_unimplemented!(test_script_run, "script", "run", "test.py");
-test_unimplemented!(test_script_python, "script", "python", "test.py");
-test_unimplemented!(test_script_java, "script", "java", "test.java");
-test_unimplemented!(test_script_list, "script", "list");
-
-// Disasm command
-test_unimplemented!(test_disasm, "disasm", "0x1000");
-
-// Other commands
-test_unimplemented!(test_batch, "batch", "test.txt");
-test_unimplemented!(test_stats, "stats");
+// No tests - all commands are now implemented