Added:

- Workspace support (`[workspace]` with deps ordering)
- `clean --all` for workspace members
Changed:
- Project root discovery for `build/run/clean` (searches parent dirs)
- Workspace paths are excluded from root source scan
- Build output now uses a Cargo-style `Compiling <name> v<version>` line
- Build time now reports total time for the whole build stage (workspace included)
- Cache hits are silent (no compile line when nothing is rebuilt)
- Safer build cache: fingerprints include headers and resolved library files

src/core/builder/clang.rs

@@ -1,7 +1,7 @@
 use crate::core::builder::BuildContext;
 use crate::platform;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::Instant;
 
@@ -12,7 +12,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language)?;
+    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
 
@@ -76,10 +76,13 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-fn collect_sources(language: &str) -> Result<Vec<String>, String> {
+pub(crate) fn collect_sources(
+    language: &str,
+    exclude_dirs: &[PathBuf],
+) -> Result<Vec<String>, String> {
     let lang = language.to_lowercase();
     let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources)?;
+    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
     sources.sort();
     if sources.is_empty() {
         return Err("No source files found in ./src".to_string());
@@ -87,13 +90,32 @@ fn collect_sources(language: &str) -> Result<Vec<String>, String> {
     Ok(sources)
 }
 
-fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(), String> {
-    let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?;
+fn collect_sources_rec(
+    dir: &str,
+    lang: &str,
+    out: &mut Vec<String>,
+    exclude_dirs: &[PathBuf],
+) -> Result<(), String> {
+    let dir_path = Path::new(dir);
+    let full_dir = if dir_path.is_absolute() {
+        dir_path.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .map_err(|err| format!("src dir error: {err}"))?
+            .join(dir_path)
+    };
+    if is_excluded(&full_dir, exclude_dirs) {
+        return Ok(());
+    }
+    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
     for entry in entries {
         let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
         let path = entry.path();
         if path.is_dir() {
-            collect_sources_rec(&path.to_string_lossy(), lang, out)?;
+            if is_excluded(&path, exclude_dirs) {
+                continue;
+            }
+            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
             continue;
         }
         if !path.is_file() {
@@ -104,7 +126,7 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(
             .and_then(|v| v.to_str())
             .unwrap_or("")
             .to_lowercase();
-        let file = path.to_string_lossy().to_string();
+        let file = normalize_source_path(&path);
         let allowed = (lang == "c" && ext == "c")
             || ((lang == "c++" || lang == "cpp" || lang == "cxx")
                 && (ext == "cpp" || ext == "cxx" || ext == "cc"))
@@ -116,6 +138,22 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(
     Ok(())
 }
 
+fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
+    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+}
+
+fn normalize_source_path(path: &Path) -> String {
+    if !path.is_absolute() {
+        return path.to_string_lossy().to_string();
+    }
+    if let Ok(base) = std::env::current_dir()
+        && let Ok(rel) = path.strip_prefix(&base)
+    {
+        return format!("./{}", rel.to_string_lossy());
+    }
+    path.to_string_lossy().to_string()
+}
+
 fn default_flags(profile: &str) -> &'static [&'static str] {
     match profile {
         "release" => &["-O3", "-DNDEBUG", "-march=native"],

src/core/builder/gas.rs

@@ -1,7 +1,7 @@
 use crate::core::builder::BuildContext;
 use crate::platform;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::Instant;
 
@@ -15,7 +15,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language)?;
+    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
 
@@ -82,10 +82,13 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-fn collect_sources(language: &str) -> Result<Vec<String>, String> {
+pub(crate) fn collect_sources(
+    language: &str,
+    exclude_dirs: &[PathBuf],
+) -> Result<Vec<String>, String> {
     let lang = language.to_lowercase();
     let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources)?;
+    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
     sources.sort();
     if sources.is_empty() {
         return Err("No source files found in ./src".to_string());
@@ -93,13 +96,32 @@ fn collect_sources(language: &str) -> Result<Vec<String>, String> {
     Ok(sources)
 }
 
-fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(), String> {
-    let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?;
+fn collect_sources_rec(
+    dir: &str,
+    lang: &str,
+    out: &mut Vec<String>,
+    exclude_dirs: &[PathBuf],
+) -> Result<(), String> {
+    let dir_path = Path::new(dir);
+    let full_dir = if dir_path.is_absolute() {
+        dir_path.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .map_err(|err| format!("src dir error: {err}"))?
+            .join(dir_path)
+    };
+    if is_excluded(&full_dir, exclude_dirs) {
+        return Ok(());
+    }
+    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
     for entry in entries {
         let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
         let path = entry.path();
         if path.is_dir() {
-            collect_sources_rec(&path.to_string_lossy(), lang, out)?;
+            if is_excluded(&path, exclude_dirs) {
+                continue;
+            }
+            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
             continue;
         }
         if !path.is_file() {
@@ -107,7 +129,7 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(
         }
         let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or("");
         let ext = ext_raw.to_lowercase();
-        let file = path.to_string_lossy().to_string();
+        let file = normalize_source_path(&path);
         let allowed = lang == "asm" && ext == "s" && ext_raw == "s";
         if allowed {
             out.push(file);
@@ -116,6 +138,22 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(
     Ok(())
 }
 
+fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
+    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+}
+
+fn normalize_source_path(path: &Path) -> String {
+    if !path.is_absolute() {
+        return path.to_string_lossy().to_string();
+    }
+    if let Ok(base) = std::env::current_dir()
+        && let Ok(rel) = path.strip_prefix(&base)
+    {
+        return format!("./{}", rel.to_string_lossy());
+    }
+    path.to_string_lossy().to_string()
+}
+
 fn build_objects(
     assembler: &str,
     sources: &[String],

src/core/builder/gcc.rs

@@ -1,7 +1,7 @@
 use crate::core::builder::BuildContext;
 use crate::platform;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::Instant;
 
@@ -12,7 +12,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language)?;
+    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
 
@@ -76,10 +76,13 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-fn collect_sources(language: &str) -> Result<Vec<String>, String> {
+pub(crate) fn collect_sources(
+    language: &str,
+    exclude_dirs: &[PathBuf],
+) -> Result<Vec<String>, String> {
     let lang = language.to_lowercase();
     let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources)?;
+    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
     sources.sort();
     if sources.is_empty() {
         return Err("No source files found in ./src".to_string());
@@ -87,13 +90,32 @@ fn collect_sources(language: &str) -> Result<Vec<String>, String> {
     Ok(sources)
 }
 
-fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(), String> {
-    let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?;
+fn collect_sources_rec(
+    dir: &str,
+    lang: &str,
+    out: &mut Vec<String>,
+    exclude_dirs: &[PathBuf],
+) -> Result<(), String> {
+    let dir_path = Path::new(dir);
+    let full_dir = if dir_path.is_absolute() {
+        dir_path.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .map_err(|err| format!("src dir error: {err}"))?
+            .join(dir_path)
+    };
+    if is_excluded(&full_dir, exclude_dirs) {
+        return Ok(());
+    }
+    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
     for entry in entries {
         let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
         let path = entry.path();
         if path.is_dir() {
-            collect_sources_rec(&path.to_string_lossy(), lang, out)?;
+            if is_excluded(&path, exclude_dirs) {
+                continue;
+            }
+            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
             continue;
         }
         if !path.is_file() {
@@ -104,7 +126,7 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(
             .and_then(|v| v.to_str())
             .unwrap_or("")
             .to_lowercase();
-        let file = path.to_string_lossy().to_string();
+        let file = normalize_source_path(&path);
         let allowed = (lang == "c" && ext == "c")
             || ((lang == "c++" || lang == "cpp" || lang == "cxx")
                 && (ext == "cpp" || ext == "cxx" || ext == "cc"))
@@ -116,6 +138,22 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(
     Ok(())
 }
 
+fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
+    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+}
+
+fn normalize_source_path(path: &Path) -> String {
+    if !path.is_absolute() {
+        return path.to_string_lossy().to_string();
+    }
+    if let Ok(base) = std::env::current_dir()
+        && let Ok(rel) = path.strip_prefix(&base)
+    {
+        return format!("./{}", rel.to_string_lossy());
+    }
+    path.to_string_lossy().to_string()
+}
+
 fn default_flags(profile: &str) -> &'static [&'static str] {
     match profile {
         "release" => &["-O3", "-DNDEBUG", "-march=native"],

src/core/builder/mod.rs

@@ -15,6 +15,7 @@ pub struct BuildContext<'a> {
     pub platform: Option<&'a str>,
     pub linker: Option<&'a str>,
     pub archiver: Option<&'a str>,
+    pub exclude_dirs: &'a [std::path::PathBuf],
     pub include_dirs: &'a [String],
     pub lib_dirs: &'a [String],
     pub libs: &'a [String],
@@ -44,3 +45,26 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
     clang::build(ctx)
 }
+
+pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    let compiler = ctx.compiler.to_lowercase();
+    if compiler.contains("clang-cl") {
+        return msvc::collect_sources(ctx.language, ctx.exclude_dirs);
+    }
+    if compiler == "as" || compiler.contains("gas") {
+        return gas::collect_sources(ctx.language, ctx.exclude_dirs);
+    }
+    if compiler.contains("nasm") {
+        return nasm::collect_sources(ctx.language, ctx.exclude_dirs);
+    }
+    if compiler.contains("gcc") || compiler.contains("g++") {
+        return gcc::collect_sources(ctx.language, ctx.exclude_dirs);
+    }
+    if compiler.contains("clang") || compiler.contains("clang++") {
+        return clang::collect_sources(ctx.language, ctx.exclude_dirs);
+    }
+    if compiler == "cl" || compiler.contains("msvc") {
+        return msvc::collect_sources(ctx.language, ctx.exclude_dirs);
+    }
+    clang::collect_sources(ctx.language, ctx.exclude_dirs)
+}

src/core/builder/msvc.rs

@@ -1,7 +1,7 @@
 use crate::core::builder::BuildContext;
 use crate::platform;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::Instant;
 
@@ -15,7 +15,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         return Err("MSVC backend does not support build.language = \"asm\"".to_string());
     }
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language)?;
+    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(compiler, &sources, &obj_dir, ctx, "obj")?;
 
@@ -100,10 +100,13 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-fn collect_sources(language: &str) -> Result<Vec<String>, String> {
+pub(crate) fn collect_sources(
+    language: &str,
+    exclude_dirs: &[PathBuf],
+) -> Result<Vec<String>, String> {
     let lang = language.to_lowercase();
     let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources)?;
+    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
     sources.sort();
     if sources.is_empty() {
         return Err("No source files found in ./src".to_string());
@@ -111,13 +114,32 @@ fn collect_sources(language: &str) -> Result<Vec<String>, String> {
     Ok(sources)
 }
 
-fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(), String> {
-    let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?;
+fn collect_sources_rec(
+    dir: &str,
+    lang: &str,
+    out: &mut Vec<String>,
+    exclude_dirs: &[PathBuf],
+) -> Result<(), String> {
+    let dir_path = Path::new(dir);
+    let full_dir = if dir_path.is_absolute() {
+        dir_path.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .map_err(|err| format!("src dir error: {err}"))?
+            .join(dir_path)
+    };
+    if is_excluded(&full_dir, exclude_dirs) {
+        return Ok(());
+    }
+    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
     for entry in entries {
         let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
         let path = entry.path();
         if path.is_dir() {
-            collect_sources_rec(&path.to_string_lossy(), lang, out)?;
+            if is_excluded(&path, exclude_dirs) {
+                continue;
+            }
+            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
             continue;
         }
         if !path.is_file() {
@@ -128,7 +150,7 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(
             .and_then(|v| v.to_str())
             .unwrap_or("")
             .to_lowercase();
-        let file = path.to_string_lossy().to_string();
+        let file = normalize_source_path(&path);
         let allowed = (lang == "c" && ext == "c")
             || ((lang == "c++" || lang == "cpp" || lang == "cxx")
                 && (ext == "cpp" || ext == "cxx" || ext == "cc"))
@@ -140,6 +162,22 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(
     Ok(())
 }
 
+fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
+    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+}
+
+fn normalize_source_path(path: &Path) -> String {
+    if !path.is_absolute() {
+        return path.to_string_lossy().to_string();
+    }
+    if let Ok(base) = std::env::current_dir()
+        && let Ok(rel) = path.strip_prefix(&base)
+    {
+        return format!("./{}", rel.to_string_lossy());
+    }
+    path.to_string_lossy().to_string()
+}
+
 fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String> {
     let lang = language.to_lowercase();
     let std = standard.to_lowercase();

src/core/builder/nasm.rs

@@ -1,7 +1,7 @@
 use crate::core::builder::BuildContext;
 use crate::platform;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::Instant;
 
@@ -15,7 +15,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language)?;
+    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
 
@@ -82,10 +82,13 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-fn collect_sources(language: &str) -> Result<Vec<String>, String> {
+pub(crate) fn collect_sources(
+    language: &str,
+    exclude_dirs: &[PathBuf],
+) -> Result<Vec<String>, String> {
     let lang = language.to_lowercase();
     let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources)?;
+    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
     sources.sort();
     if sources.is_empty() {
         return Err("No source files found in ./src".to_string());
@@ -93,13 +96,32 @@ fn collect_sources(language: &str) -> Result<Vec<String>, String> {
     Ok(sources)
 }
 
-fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(), String> {
-    let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?;
+fn collect_sources_rec(
+    dir: &str,
+    lang: &str,
+    out: &mut Vec<String>,
+    exclude_dirs: &[PathBuf],
+) -> Result<(), String> {
+    let dir_path = Path::new(dir);
+    let full_dir = if dir_path.is_absolute() {
+        dir_path.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .map_err(|err| format!("src dir error: {err}"))?
+            .join(dir_path)
+    };
+    if is_excluded(&full_dir, exclude_dirs) {
+        return Ok(());
+    }
+    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
     for entry in entries {
         let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
         let path = entry.path();
         if path.is_dir() {
-            collect_sources_rec(&path.to_string_lossy(), lang, out)?;
+            if is_excluded(&path, exclude_dirs) {
+                continue;
+            }
+            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
             continue;
         }
         if !path.is_file() {
@@ -107,7 +129,7 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(
         }
         let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or("");
         let ext = ext_raw.to_lowercase();
-        let file = path.to_string_lossy().to_string();
+        let file = normalize_source_path(&path);
         let allowed = lang == "asm" && (ext == "asm" || (ext == "s" && ext_raw == "s"));
         if allowed {
             out.push(file);
@@ -116,6 +138,22 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(
     Ok(())
 }
 
+fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
+    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+}
+
+fn normalize_source_path(path: &Path) -> String {
+    if !path.is_absolute() {
+        return path.to_string_lossy().to_string();
+    }
+    if let Ok(base) = std::env::current_dir()
+        && let Ok(rel) = path.strip_prefix(&base)
+    {
+        return format!("./{}", rel.to_string_lossy());
+    }
+    path.to_string_lossy().to_string()
+}
+
 fn build_objects(
     assembler: &str,
     sources: &[String],

src/core/config.rs

@@ -115,7 +115,7 @@ impl Config {
             .and_then(|v| v.as_table())
             .ok_or_else(|| ConfigError::Invalid("missing [build]".into()))?;
 
-        for key in ["language", "standard", "compiler", "kind"] {
+        for key in ["language", "standard", "compiler"] {
             let value = build.get(key).and_then(|v| v.as_str()).unwrap_or("");
             if value.trim().is_empty() {
                 return Err(ConfigError::Invalid(format!("build.{key} is empty")));
@@ -140,10 +140,11 @@ impl Config {
         }
         if let Some(kind) = build.get("kind").and_then(|v| v.as_str()) {
             let kind = kind.trim();
-            if kind != "bin" && kind != "staticlib" && kind != "sharedlib" {
+            if !kind.is_empty() && kind != "bin" && kind != "staticlib" && kind != "sharedlib" {
                 return Err(ConfigError::Invalid("build.kind is invalid".into()));
             }
         }
+        self.validate_workspace()?;
         Ok(())
     }
 
@@ -159,6 +160,39 @@ impl Config {
     }
 }
 
+impl Config {
+    fn validate_workspace(&self) -> Result<(), ConfigError> {
+        let Some(workspace) = self.get("workspace").and_then(|v| v.as_table()) else {
+            return Ok(());
+        };
+        for (name, value) in workspace {
+            let tbl = value
+                .as_table()
+                .ok_or_else(|| ConfigError::Invalid(format!("workspace.{name} must be a table")))?;
+            let path = tbl.get("path").and_then(|v| v.as_str()).unwrap_or("");
+            if path.trim().is_empty() {
+                return Err(ConfigError::Invalid(format!(
+                    "workspace.{name}.path is empty"
+                )));
+            }
+            if let Some(deps) = tbl.get("deps") {
+                let arr = deps.as_array().ok_or_else(|| {
+                    ConfigError::Invalid(format!("workspace.{name}.deps must be array"))
+                })?;
+                for item in arr {
+                    let s = item.as_str().unwrap_or("");
+                    if s.trim().is_empty() {
+                        return Err(ConfigError::Invalid(format!(
+                            "workspace.{name}.deps contains empty value"
+                        )));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
 fn read_toml(path: &Path) -> Result<Value, ConfigError> {
     let content = fs::read_to_string(path)?;
     Ok(toml::from_str(&content)?)

src/core/mod.rs

@@ -2,3 +2,4 @@ pub mod builder;
 pub mod config;
 pub mod deps;
 pub mod runner;
+pub mod workspace;

src/core/workspace.rs

@@ -0,0 +1,124 @@
+use crate::core::config::Config;
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use toml::Value;
+
+#[derive(Debug, Clone)]
+pub struct WorkspaceMember {
+    pub name: String,
+    pub path: PathBuf,
+    pub deps: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Workspace {
+    pub members: Vec<WorkspaceMember>,
+}
+
+pub fn parse_workspace(config: &Config, root: &Path) -> Result<Option<Workspace>, String> {
+    let table = match config.get("workspace").and_then(|v| v.as_table()) {
+        Some(t) => t,
+        None => return Ok(None),
+    };
+
+    let mut members = Vec::new();
+    for (name, value) in table {
+        let tbl = value
+            .as_table()
+            .ok_or_else(|| format!("workspace.{name} must be a table with path and deps"))?;
+        let path_raw = tbl
+            .get("path")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| format!("workspace.{name}.path is required"))?;
+        let path = resolve_path(root, path_raw)?;
+        if !path.join("dcr.toml").is_file() {
+            return Err(format!(
+                "workspace.{name}.path does not contain dcr.toml: {}",
+                path.display()
+            ));
+        }
+        let deps = parse_deps(tbl.get("deps"))?;
+        members.push(WorkspaceMember {
+            name: name.to_string(),
+            path,
+            deps,
+        });
+    }
+
+    let mut ws = Workspace { members };
+    ws.members = topo_sort(&ws.members)?;
+    Ok(Some(ws))
+}
+
+fn resolve_path(root: &Path, raw: &str) -> Result<PathBuf, String> {
+    let p = Path::new(raw);
+    let full = if p.is_absolute() {
+        p.to_path_buf()
+    } else {
+        root.join(p)
+    };
+    Ok(full)
+}
+
+fn parse_deps(value: Option<&Value>) -> Result<Vec<String>, String> {
+    let Some(value) = value else {
+        return Ok(Vec::new());
+    };
+    let arr = value
+        .as_array()
+        .ok_or_else(|| "workspace deps must be an array of strings".to_string())?;
+    let mut out = Vec::new();
+    for item in arr {
+        let s = item
+            .as_str()
+            .ok_or_else(|| "workspace deps must be an array of strings".to_string())?;
+        out.push(s.to_string());
+    }
+    Ok(out)
+}
+
+fn topo_sort(members: &[WorkspaceMember]) -> Result<Vec<WorkspaceMember>, String> {
+    let mut map = HashMap::new();
+    for m in members {
+        map.insert(m.name.clone(), m.clone());
+    }
+    let mut state: HashMap<String, u8> = HashMap::new();
+    let mut order: Vec<WorkspaceMember> = Vec::new();
+
+    for name in map.keys() {
+        if *state.get(name).unwrap_or(&0) == 0 {
+            visit(name, &map, &mut state, &mut order)?;
+        }
+    }
+    Ok(order)
+}
+
+fn visit(
+    name: &str,
+    map: &HashMap<String, WorkspaceMember>,
+    state: &mut HashMap<String, u8>,
+    order: &mut Vec<WorkspaceMember>,
+) -> Result<(), String> {
+    match state.get(name).copied().unwrap_or(0) {
+        1 => return Err(format!("workspace dependency cycle at {name}")),
+        2 => return Ok(()),
+        _ => {}
+    }
+    state.insert(name.to_string(), 1);
+    let member = map
+        .get(name)
+        .ok_or_else(|| format!("unknown workspace member {name}"))?;
+    let mut seen = HashSet::new();
+    for dep in &member.deps {
+        if !seen.insert(dep) {
+            continue;
+        }
+        if !map.contains_key(dep) {
+            return Err(format!("workspace dependency '{dep}' not found"));
+        }
+        visit(dep, map, state, order)?;
+    }
+    state.insert(name.to_string(), 2);
+    order.push(member.clone());
+    Ok(())
+}