diff --git a/backend/app/main.py b/backend/app/main.py
index 1c7e480..15302d7 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -524,6 +524,26 @@ async def upload_creative_asset(file: UploadFile = File(...)) -> AssetRecord:
     return await asset_store.save_bytes(data, filename=filename, media_type=content_type)
 
 
+class AssetUploadBase64Request(BaseModel):
+    filename: str
+    content_base64: str
+    media_type: str = "image"
+
+
+@app.post("/api/v1/creative/upload-base64", response_model=AssetRecord)
+async def upload_creative_asset_base64(req: AssetUploadBase64Request) -> AssetRecord:
+    """Upload asset encoded in base64 (used by CLI and programmatic API clients)."""
+    import base64
+    import binascii
+    try:
+        data = base64.b64decode(req.content_base64, validate=True)
+    except (binascii.Error, ValueError) as exc:
+        raise HTTPException(status_code=400, detail=f"Invalid base64 payload: {exc}")
+    return await asset_store.save_bytes(data, filename=req.filename, media_type=req.media_type)
+
+
+
+
 # ---------------------------------------------------------------------------
 # Cloud Providers & BYOK Credentials Endpoints (M4)
 # ---------------------------------------------------------------------------
diff --git a/backend/tests/test_m8_cli.py b/backend/tests/test_m8_cli.py
new file mode 100644
index 0000000..164625b
--- /dev/null
+++ b/backend/tests/test_m8_cli.py
@@ -0,0 +1,76 @@
+"""Tests for Milestone M8: Unified Berry CLI backend support."""
+
+import asyncio
+import pytest
+from fastapi.testclient import TestClient
+
+from app.main import app, active_cancellations
+
+client = TestClient(app)
+
+
+def test_upload_base64_image_success():
+    """Test successful base64 asset upload via the CLI/backend endpoint."""
+    # 1x1 transparent PNG in base64
+    tiny_png_b64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="
+
+    resp = client.post(
+        "/api/v1/creative/upload-base64",
+        json={
+            "filename": "cli_test_image.png",
+            "content_base64": tiny_png_b64,
+            "media_type": "image",
+        },
+    )
+
+    assert resp.status_code == 200
+    data = resp.json()
+    assert "id" in data
+    assert data["filename"] == "cli_test_image.png"
+    assert data["media_type"] == "image"
+    assert data["byte_size"] > 0
+    assert "content_hash" in data
+
+
+def test_upload_base64_invalid_data():
+    """Test handling of invalid base64 payload."""
+    resp = client.post(
+        "/api/v1/creative/upload-base64",
+        json={
+            "filename": "bad.png",
+            "content_base64": "not-valid-base-64!!!",
+            "media_type": "image",
+        },
+    )
+    assert resp.status_code == 400
+    assert "Invalid base64 payload" in resp.json()["detail"]
+
+
+def test_active_tasks_and_cancel_endpoints():
+    """Test task inspection and cancellation endpoints."""
+    # Register an active task cancellation token
+    test_task_id = "test-task-cli-123"
+    cancel_event = asyncio.Event()
+    active_cancellations[test_task_id] = cancel_event
+
+    try:
+        # Active tasks query
+        resp = client.get("/api/v1/tasks/active")
+        assert resp.status_code == 200
+        tasks = resp.json()
+        assert "tasks" in tasks
+        assert any(t["id"] == test_task_id for t in tasks["tasks"])
+
+        # Cancel the active task
+        cancel_resp = client.post(f"/api/v1/tasks/{test_task_id}/cancel")
+        assert cancel_resp.status_code == 200
+        data = cancel_resp.json()
+        assert data["task_id"] == test_task_id
+        assert data["status"] == "cancelled"
+        assert cancel_event.is_set()
+
+        # Cancel a non-existent task returns 404
+        nonexistent_resp = client.post("/api/v1/tasks/nonexistent-task-id/cancel")
+        assert nonexistent_resp.status_code == 404
+    finally:
+        active_cancellations.pop(test_task_id, None)
diff --git a/docs/CLI_REFERENCE.md b/docs/CLI_REFERENCE.md
new file mode 100644
index 0000000..ad128d9
--- /dev/null
+++ b/docs/CLI_REFERENCE.md
@@ -0,0 +1,171 @@
+# Berry AI Studio - Unified Command-Line Interface (CLI) Reference
+
+The Berry AI Studio CLI provides headless, scriptable, and programmatic access to creative workflows, process supervision, engine lifecycle, task management, and system diagnostics. The CLI is embedded in the Rust launcher executable (`berry.exe` on Windows, `berry` on Linux/macOS) and communicates directly with the Berry Core backend over localhost loopback HTTP REST and WebSocket APIs.
+
+---
+
+## 1. Quick Start
+
+Ensure the Berry backend is running or launch it via the supervisor:
+```bash
+# Launch GUI workspace and environment supervisor
+berry
+
+# Check status of core, engines, and model catalog
+berry status
+
+# Check hardware and system diagnostics
+berry system
+```
+
+---
+
+## 2. Global Options and Environment Variables
+
+| Option / Variable | Description | Default |
+| :--- | :--- | :--- |
+| `BERRY_PORT` | Custom port for Berry AI Studio backend HTTP server | `8000` |
+| `--json` | Format output as structured JSON for automation and scripts | `false` |
+| `--help`, `-h` | Display command syntax and available subcommands | - |
+
+Exit Codes:
+- `0`: Success
+- `1`: Error (validation failure, connectivity issue, or engine execution error)
+
+---
+
+## 3. Creative Workflow Execution (`berry run`)
+
+Executes high-level creative actions directly against local engines (ComfyUI / WebUI) or configured cloud BYOK providers (Fal.ai, SiliconFlow). Supports automatic image/mask uploading, deterministic caching, and output downloading.
+
+### Syntax
+```bash
+berry run <action> [options]
+```
+
+### Supported Actions
+- `txt2img`: Text-to-image generation
+- `img2img`: Image-to-image styling and transformation
+- `inpaint`: Mask-based image editing and replacement
+- `upscale`: Image upscaling and resolution enhancement
+- `txt2video`: Text-to-video generation (e.g. CogVideoX / AnimateDiff)
+- `img2video`: Image-to-video animation (e.g. SVD XT / Fast SVD)
+
+### Command Options
+| Option | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `--prompt <text>` | String | `""` | Positive prompt describing the desired generation |
+| `--negative-prompt <text>` | String | Default negative | Negative prompt describing unwanted attributes |
+| `--engine <id>` | String | `managed_comfyui` | Target engine: `managed_comfyui`, `managed_webui`, `fal_ai`, `siliconflow` |
+| `--model <name>` | String | `v1-5-pruned-emaonly.safetensors` | Checkpoint or cloud model identifier |
+| `--aspect-ratio <ratio>` | String | `1:1` | Aspect ratio: `1:1`, `16:9`, `9:16`, `4:3`, `3:4` |
+| `--seed <int>` | Integer | `-1` | Random seed (`-1` for randomized generation) |
+| `--steps <int>` | Integer | `20` | Denoising inference steps |
+| `--cfg <float>` | Float | `7.0` | Classifier-Free Guidance (CFG) scale |
+| `--denoise <float>` | Float | `0.75` | Denoise strength for `img2img` and `inpaint` |
+| `--image <file>` | Path | None | Path to local input image for `img2img`, `inpaint`, `upscale`, or `img2video` |
+| `--mask <file>` | Path | None | Path to local mask image for `inpaint` |
+| `--fps <int>` | Integer | `16` | Video framerate (frames per second) |
+| `--frames <int>` | Integer | `25` | Total number of video frames to generate |
+| `--motion <int>` | Integer | `127` | Motion bucket ID / intensity for video animation |
+| `--upscale-factor <float>` | Float | `2.0` | Scale multiplier for `upscale` action |
+| `--output <file>` | Path | None | Destination path to automatically download and save the resulting media file |
+| `--json` | Flag | False | Output result as structured JSON to stdout |
+
+### Examples
+
+#### Text-to-Image Generation
+```bash
+berry run txt2img \
+  --prompt "A retro sci-fi rover exploring a neon crater on Mars" \
+  --aspect-ratio 16:9 \
+  --steps 25 \
+  --output ./mars_rover.png
+```
+
+#### Image-to-Video Animation
+```bash
+berry run img2video \
+  --image ./mars_rover.png \
+  --fps 24 \
+  --frames 49 \
+  --motion 150 \
+  --output ./mars_rover.mp4
+```
+
+#### JSON Pipeline Integration
+```bash
+berry run txt2img --prompt "cyberpunk street market" --json | jq .image_url
+```
+
+---
+
+## 4. Task Management (`berry tasks`)
+
+Inspect and cancel background generation and workflow tasks.
+
+### Syntax
+```bash
+# List all in-flight tasks
+berry tasks list [--json]
+
+# Cancel an active task by task ID
+berry tasks cancel <task_id> [--json]
+```
+
+### Examples
+```bash
+berry tasks list
+# Active Creative Tasks:
+#   - Task [c997ff97-15ef-4573-8efd-bb74b09e44eb] : action=txt2video, engine=managed_comfyui
+
+berry tasks cancel c997ff97-15ef-4573-8efd-bb74b09e44eb
+# [OK] Task cancellation signal sent for c997ff97-15ef-4573-8efd-bb74b09e44eb
+```
+
+---
+
+## 5. System Diagnostics (`berry system`)
+
+Queries hardware readiness, discrete GPU detection, CUDA / ROCm / DirectML availability, memory capacity, and running engine endpoints.
+
+### Syntax
+```bash
+berry system [--json]
+```
+
+---
+
+## 6. Engine and Environment Lifecycle
+
+| Command | Description |
+| :--- | :--- |
+| `berry status` | Unified status of Berry Core, local managed runtimes, external engines, and model index |
+| `berry stop [--force]` | Graceful or forced shutdown of core and child engine processes |
+| `berry manager` | Launch or focus the web-based Environment Manager |
+| `berry engine start <comfyui\|webui>` | Start managed engine subprocess |
+| `berry engine stop <comfyui\|webui>` | Stop managed engine subprocess |
+| `berry engine install <comfyui\|webui>` | Initiate isolated engine installation |
+| `berry engine update <comfyui\|webui>` | Update engine Git repository with dirty-check & rollback protection |
+
+---
+
+## 7. Model Inventory Management (`berry models`)
+
+| Command | Description |
+| :--- | :--- |
+| `berry models list` | List indexed models, architecture, file size, and paths |
+| `berry models rescan` | Trigger filesystem rescan across all registered model roots |
+| `berry models roots` | Display configured model storage roots |
+| `berry models add-root <path> <label>` | Add a new model root directory |
+| `berry models remove-root <root_id>` | Remove a registered model root directory |
+
+---
+
+## 8. Updates (`berry update`)
+
+| Command | Description |
+| :--- | :--- |
+| `berry update check` | Check for updates to Berry Studio and managed engines |
+| `berry update app` | Update Berry application core |
+| `berry update engine <comfyui\|webui>` | Update specified engine |
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
new file mode 100644
index 0000000..bc650d6
--- /dev/null
+++ b/launcher/src/cli.rs
@@ -0,0 +1,268 @@
+//! Unified CLI for Berry AI Studio Creative Execution & Management (M8).
+
+use std::path::Path;
+use crate::client::{BerryClient, CliCreativeResult};
+
+fn get_flag_value(args: &[String], flag: &str) -> Option<String> {
+    for i in 0..args.len() {
+        if args[i] == flag && i + 1 < args.len() {
+            return Some(args[i + 1].clone());
+        }
+    }
+    None
+}
+
+fn has_flag(args: &[String], flag: &str) -> bool {
+    args.iter().any(|a| a == flag)
+}
+
+pub fn handle_run_command(client: &BerryClient, args: &[String]) -> Result<(), String> {
+    if args.is_empty() {
+        return Err("Action required for 'berry run'. Usage: berry run <txt2img|img2img|inpaint|upscale|txt2video|img2video> [options]".to_string());
+    }
+
+    let action = &args[0];
+    let is_json = has_flag(args, "--json");
+
+    let prompt = get_flag_value(args, "--prompt").unwrap_or_default();
+    let negative_prompt = get_flag_value(args, "--negative-prompt")
+        .unwrap_or_else(|| "low quality, blurry, deformed, bad anatomy".to_string());
+    let engine = get_flag_value(args, "--engine").unwrap_or_else(|| "managed_comfyui".to_string());
+    let model = get_flag_value(args, "--model")
+        .unwrap_or_else(|| "v1-5-pruned-emaonly.safetensors".to_string());
+    let aspect_ratio = get_flag_value(args, "--aspect-ratio").unwrap_or_else(|| "1:1".to_string());
+    let seed: i64 = get_flag_value(args, "--seed")
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(-1);
+    let steps: i64 = get_flag_value(args, "--steps")
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(20);
+    let cfg: f64 = get_flag_value(args, "--cfg")
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(7.0);
+    let denoise: f64 = get_flag_value(args, "--denoise")
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(0.75);
+    let fps: u32 = get_flag_value(args, "--fps")
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(16);
+    let frames: u32 = get_flag_value(args, "--frames")
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(25);
+    let motion: u32 = get_flag_value(args, "--motion")
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(127);
+    let upscale_factor: f64 = get_flag_value(args, "--upscale-factor")
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(2.0);
+    let output_path = get_flag_value(args, "--output");
+
+    // Optional input image upload
+    let mut input_image_id: Option<String> = None;
+    if let Some(image_path_str) = get_flag_value(args, "--image") {
+        let p = Path::new(&image_path_str);
+        if !p.exists() {
+            return Err(format!("Input image file not found: {}", image_path_str));
+        }
+        if !is_json {
+            println!("[*] Uploading input image: {}", image_path_str);
+        }
+        let asset_id = client.upload_asset_from_file(p)?;
+        input_image_id = Some(asset_id);
+    }
+
+    // Optional mask image upload
+    let mut mask_image_id: Option<String> = None;
+    if let Some(mask_path_str) = get_flag_value(args, "--mask") {
+        let p = Path::new(&mask_path_str);
+        if !p.exists() {
+            return Err(format!("Input mask file not found: {}", mask_path_str));
+        }
+        if !is_json {
+            println!("[*] Uploading mask image: {}", mask_path_str);
+        }
+        let asset_id = client.upload_asset_from_file(p)?;
+        mask_image_id = Some(asset_id);
+    }
+
+    let payload = serde_json::json!({
+        "action": action,
+        "prompt": prompt,
+        "negative_prompt": negative_prompt,
+        "engine_id": engine,
+        "model": model,
+        "aspect_ratio": aspect_ratio,
+        "seed": seed,
+        "steps": steps,
+        "cfg_scale": cfg,
+        "denoise": denoise,
+        "input_image_id": input_image_id,
+        "mask_image_id": mask_image_id,
+        "fps": fps,
+        "num_frames": frames,
+        "motion_bucket_id": motion,
+        "upscale_factor": upscale_factor
+    });
+
+    if !is_json {
+        println!("========================================================");
+        println!("          Berry AI Studio - Task Dispatch");
+        println!("========================================================");
+        println!("Action       : {}", action);
+        println!("Prompt       : \"{}\"", prompt);
+        println!("Engine       : {}", engine);
+        println!("Model        : {}", model);
+        println!("Ratio / Seed : {} / {}", aspect_ratio, seed);
+        println!("Executing task asynchronously...\n");
+    }
+
+    let result: CliCreativeResult = client.execute_creative(payload)?;
+
+    if !result.success {
+        let err = result.error_message.unwrap_or_else(|| "Unknown failure".to_string());
+        if is_json {
+            let json_err = serde_json::json!({ "success": false, "error": err });
+            println!("{}", serde_json::to_string_pretty(&json_err).unwrap());
+        } else {
+            eprintln!("[ERROR] Execution failed: {}", err);
+        }
+        return Err(err);
+    }
+
+    // Handle output file download if requested
+    let media_url = result.video_url.as_deref().or(result.image_url.as_deref());
+    let mut saved_to: Option<String> = None;
+
+    if let (Some(dest_str), Some(url)) = (output_path, media_url) {
+        if !is_json {
+            println!("[*] Downloading generated output to: {}", dest_str);
+        }
+        let bytes = client.download_asset_bytes(url)?;
+        std::fs::write(&dest_str, bytes).map_err(|e| format!("Failed to write output file {}: {}", dest_str, e))?;
+        saved_to = Some(dest_str);
+    }
+
+    if is_json {
+        let mut out = serde_json::to_value(&result).unwrap_or(serde_json::Value::Null);
+        if let Some(dest) = saved_to {
+            out["saved_file"] = serde_json::Value::String(dest);
+        }
+        println!("{}", serde_json::to_string_pretty(&out).unwrap());
+    } else {
+        println!("========================================================");
+        println!("                 Task Completed");
+        println!("========================================================");
+        println!("Status       : Success");
+        println!("Task ID      : {}", result.task_id);
+        println!("Dimensions   : {}x{}", result.width, result.height);
+        if let Some(fps_val) = result.fps {
+            println!("Framerate    : {} fps", fps_val);
+        }
+        if let Some(dur) = result.duration_seconds {
+            println!("Duration     : {:.1}s", dur);
+        }
+        if let Some(url) = media_url {
+            println!("Asset URL    : {}", url);
+        }
+        println!("Cached       : {}", if result.is_cached { "Yes (idempotent cache hit)" } else { "No (fresh inference)" });
+        if let Some(dest) = saved_to {
+            println!("Saved File   : {}", dest);
+        }
+        println!("========================================================\n");
+    }
+
+    Ok(())
+}
+
+pub fn handle_tasks_command(client: &BerryClient, args: &[String]) -> Result<(), String> {
+    if args.is_empty() {
+        return Err("Subcommand required. Usage: berry tasks <list|cancel <task_id>>".to_string());
+    }
+
+    let is_json = has_flag(args, "--json");
+
+    match args[0].as_str() {
+        "list" => {
+            let tasks = client.list_active_tasks()?;
+            if is_json {
+                println!("{}", serde_json::to_string_pretty(&tasks).unwrap());
+            } else {
+                println!("\nActive Creative Tasks:");
+                if let Some(map) = tasks.as_object() {
+                    if map.is_empty() {
+                        println!("  (No in-flight creative tasks)");
+                    } else {
+                        for (task_id, info) in map {
+                            println!("  - Task [{}] : action={}, engine={}",
+                                task_id,
+                                info.get("action").and_then(|v| v.as_str()).unwrap_or("?"),
+                                info.get("engine").and_then(|v| v.as_str()).unwrap_or("?")
+                            );
+                        }
+                    }
+                }
+                println!();
+            }
+        }
+        "cancel" => {
+            if args.len() < 2 {
+                return Err("Usage: berry tasks cancel <task_id>".to_string());
+            }
+            let task_id = &args[1];
+            let res = client.cancel_task(task_id)?;
+            if is_json {
+                println!("{}", serde_json::to_string_pretty(&res).unwrap());
+            } else {
+                println!("[OK] Task cancellation signal sent for {}", task_id);
+            }
+        }
+        other => return Err(format!("Unknown tasks subcommand '{}'. Expected list, cancel.", other)),
+    }
+
+    Ok(())
+}
+
+pub fn handle_system_command(client: &BerryClient, args: &[String]) -> Result<(), String> {
+    let is_json = has_flag(args, "--json");
+    let info = client.get_system_info()?;
+
+    if is_json {
+        println!("{}", serde_json::to_string_pretty(&info).unwrap());
+    } else {
+        println!("\n========================================================");
+        println!("               Berry AI Studio Diagnostics");
+        println!("========================================================");
+        if let Some(obj) = info.as_object() {
+            for (k, v) in obj {
+                println!("  {:<20} : {}", k, v);
+            }
+        }
+        println!("========================================================\n");
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_flag_parsing() {
+        let args = vec![
+            "txt2img".to_string(),
+            "--prompt".to_string(),
+            "cyberpunk city".to_string(),
+            "--json".to_string(),
+            "--steps".to_string(),
+            "30".to_string(),
+        ];
+
+        assert_eq!(get_flag_value(&args, "--prompt"), Some("cyberpunk city".to_string()));
+        assert_eq!(get_flag_value(&args, "--steps"), Some("30".to_string()));
+        assert_eq!(get_flag_value(&args, "--nonexistent"), None);
+
+        assert!(has_flag(&args, "--json"));
+        assert!(!has_flag(&args, "--yaml"));
+    }
+}
diff --git a/launcher/src/client.rs b/launcher/src/client.rs
index f6e1147..6a0e0c5 100644
--- a/launcher/src/client.rs
+++ b/launcher/src/client.rs
@@ -88,6 +88,22 @@ pub struct EngineUpdateManifest {
     pub rollback_performed: bool,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CliCreativeResult {
+    pub success: bool,
+    pub task_id: String,
+    pub asset_id: Option<String>,
+    pub image_url: Option<String>,
+    pub video_url: Option<String>,
+    pub width: u32,
+    pub height: u32,
+    pub duration_seconds: Option<f64>,
+    pub fps: Option<u32>,
+    pub provenance: Option<serde_json::Value>,
+    pub is_cached: bool,
+    pub error_message: Option<String>,
+}
+
 pub struct BerryClient {
     base_url: String,
     agent: ureq::Agent,
@@ -188,5 +204,106 @@ impl BerryClient {
         let mut resp = self.agent.post(&url).send_empty().map_err(|e| format!("Failed to update application: {}", e))?;
         resp.body_mut().read_json::<serde_json::Value>().map_err(|e| format!("JSON decode failed: {}", e))
     }
+
+    pub fn execute_creative(&self, payload: serde_json::Value) -> Result<CliCreativeResult, String> {
+        let url = format!("{}/api/v1/creative/execute", self.base_url);
+        let creative_agent = ureq::Agent::config_builder()
+            .timeout_global(Some(Duration::from_secs(300)))
+            .build()
+            .new_agent();
+        let mut resp = creative_agent.post(&url)
+            .send_json(payload)
+            .map_err(|e| format!("Creative execution request failed: {}", e))?;
+        resp.body_mut().read_json::<CliCreativeResult>().map_err(|e| format!("JSON decode failed: {}", e))
+    }
+
+    pub fn download_asset_bytes(&self, path_or_url: &str) -> Result<Vec<u8>, String> {
+        let url = if path_or_url.starts_with("http") {
+            path_or_url.to_string()
+        } else {
+            format!("{}{}", self.base_url, path_or_url)
+        };
+        let mut resp = self.agent.get(&url).call().map_err(|e| format!("Failed to download asset from {}: {}", url, e))?;
+        let mut bytes = Vec::new();
+        std::io::Read::read_to_end(&mut resp.body_mut().as_reader(), &mut bytes)
+            .map_err(|e| format!("Failed to read asset bytes: {}", e))?;
+        Ok(bytes)
+    }
+
+    pub fn list_active_tasks(&self) -> Result<serde_json::Value, String> {
+        let url = format!("{}/api/v1/tasks/active", self.base_url);
+        let mut resp = self.agent.get(&url).call().map_err(|e| format!("Failed to list active tasks: {}", e))?;
+        resp.body_mut().read_json::<serde_json::Value>().map_err(|e| format!("JSON decode failed: {}", e))
+    }
+
+    pub fn cancel_task(&self, task_id: &str) -> Result<serde_json::Value, String> {
+        let url = format!("{}/api/v1/tasks/{}/cancel", self.base_url, task_id);
+        let mut resp = self.agent.post(&url).send_empty().map_err(|e| format!("Failed to cancel task {}: {}", task_id, e))?;
+        resp.body_mut().read_json::<serde_json::Value>().map_err(|e| format!("JSON decode failed: {}", e))
+    }
+
+    pub fn get_system_info(&self) -> Result<serde_json::Value, String> {
+        let url = format!("{}/api/v1/system/info", self.base_url);
+        let mut resp = self.agent.get(&url).call().map_err(|e| format!("Failed to get system info: {}", e))?;
+        resp.body_mut().read_json::<serde_json::Value>().map_err(|e| format!("JSON decode failed: {}", e))
+    }
+
+    pub fn upload_asset_from_file(&self, file_path: &std::path::Path) -> Result<String, String> {
+        let bytes = std::fs::read(file_path).map_err(|e| format!("Failed to read file {}: {}", file_path.display(), e))?;
+        let filename = file_path.file_name().and_then(|n| n.to_str()).unwrap_or("input_asset.png");
+        let b64 = base64_encode(&bytes);
+        let url = format!("{}/api/v1/creative/upload-base64", self.base_url);
+        let is_video = filename.ends_with(".mp4") || filename.ends_with(".webm");
+        let payload = serde_json::json!({
+            "filename": filename,
+            "content_base64": b64,
+            "media_type": if is_video { "video" } else { "image" }
+        });
+        let mut resp = self.agent.post(&url)
+            .send_json(payload)
+            .map_err(|e| format!("Failed to upload asset: {}", e))?;
+        let res: serde_json::Value = resp.body_mut().read_json().map_err(|e| format!("JSON decode failed: {}", e))?;
+        res.get("id").and_then(|id| id.as_str()).map(|s| s.to_string()).ok_or_else(|| "Missing asset ID in response".to_string())
+    }
 }
 
+pub fn base64_encode(data: &[u8]) -> String {
+    const CHARSET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let mut result = String::with_capacity((data.len() + 2) / 3 * 4);
+    for chunk in data.chunks(3) {
+        let b0 = chunk[0] as usize;
+        let b1 = if chunk.len() > 1 { chunk[1] as usize } else { 0 };
+        let b2 = if chunk.len() > 2 { chunk[2] as usize } else { 0 };
+        let triple = (b0 << 16) | (b1 << 8) | b2;
+        result.push(CHARSET[(triple >> 18) & 0x3F] as char);
+        result.push(CHARSET[(triple >> 12) & 0x3F] as char);
+        if chunk.len() > 1 {
+            result.push(CHARSET[(triple >> 6) & 0x3F] as char);
+        } else {
+            result.push('=');
+        }
+        if chunk.len() > 2 {
+            result.push(CHARSET[triple & 0x3F] as char);
+        } else {
+            result.push('=');
+        }
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_base64_encode() {
+        assert_eq!(base64_encode(b""), "");
+        assert_eq!(base64_encode(b"f"), "Zg==");
+        assert_eq!(base64_encode(b"fo"), "Zm8=");
+        assert_eq!(base64_encode(b"foo"), "Zm9v");
+        assert_eq!(base64_encode(b"Berry AI Studio"), "QmVycnkgQUkgU3R1ZGlv");
+    }
+}
+
+
+
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index ff40191..bde988a 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -1,6 +1,7 @@
 //! Berry AI Studio - Launcher & Environment Manager (L01-L12).
 
 mod backend;
+mod cli;
 mod client;
 mod port;
 mod single_instance;
@@ -51,6 +52,9 @@ fn print_help() {
     println!("  berry engine <action> <type> Manage engine lifecycle (start, stop, install, update)");
     println!("  berry models <action> [...]  Manage model inventory (list, rescan, add, remove)");
     println!("  berry update <check|app|engine> Manage application and engine updates");
+    println!("  berry run <action> [options] Execute creative workflows from CLI (txt2img, img2img, upscale, txt2video, img2video)");
+    println!("  berry tasks <list|cancel>   Inspect or cancel background execution tasks");
+    println!("  berry system [--json]       Display hardware readiness and engine availability");
     println!("  berry help                  Show this help screen");
 }
 
@@ -66,6 +70,26 @@ fn main() {
 
     if args.len() > 1 {
         match args[1].as_str() {
+            "run" => {
+                if let Err(e) = cli::handle_run_command(&client, &args[2..]) {
+                    eprintln!("[ERROR] {}", e);
+                    std::process::exit(1);
+                }
+            }
+
+            "tasks" => {
+                if let Err(e) = cli::handle_tasks_command(&client, &args[2..]) {
+                    eprintln!("[ERROR] {}", e);
+                    std::process::exit(1);
+                }
+            }
+
+            "system" => {
+                if let Err(e) = cli::handle_system_command(&client, &args[2..]) {
+                    eprintln!("[ERROR] {}", e);
+                    std::process::exit(1);
+                }
+            }
             "status" => {
                 match client.get_status() {
                     Ok(status) => {