feat(workspace): parse [workspace] section and .workspace = true

- Add WorkspaceConfig struct to Manifest (members, exclude, dependencies)
- Parse [workspace] section with members array and version declarations
- Parse [workspace.dependencies] and [workspace.dependencies.<ns>]
- Support .workspace = true in dependency specs for version inheritance
- Make [package] optional when [workspace] is present (virtual workspace)
- Add 3 unit tests for workspace parsing

Author: Sunrisepeak

src/manifest.cppm

@@ -139,6 +139,21 @@ struct PackConfig {
     std::vector<std::string>            forceBundle;   // libs to bundle even if PEP 600 says skip
 };
 
+// `[workspace]` — multi-package workspace support (0.0.11+).
+//
+// A workspace root mcpp.toml declares member packages. Members share
+// a unified lock file, target directory, and can inherit dependency
+// versions via `.workspace = true`.
+//
+// Virtual workspace (no [package]): pure management node.
+// Rooted workspace ([package] + [workspace]): root is also a package.
+struct WorkspaceConfig {
+    std::vector<std::string>                            members;       // relative paths to member dirs
+    std::vector<std::string>                            exclude;       // paths to exclude
+    std::map<std::string, DependencySpec>               dependencies;  // [workspace.dependencies]
+    bool                                                present = false;
+};
+
 struct Manifest {
     std::filesystem::path       sourcePath;    // mcpp.toml's filesystem path
 
@@ -156,9 +171,6 @@ struct Manifest {
     BuildConfig                 buildConfig;
 
     // [target.<triple>] tables — empty if user didn't declare any.
-    // Triple keys are accepted in either GCC form (x86_64-linux-musl)
-    // or Rust form (x86_64-unknown-linux-musl); both are normalised by
-    // stripping `-unknown-` on read.
     std::map<std::string, TargetEntry> targetOverrides;
 
     // [pack] — `mcpp pack` config (see docs/35-pack-design.md).
@@ -167,6 +179,9 @@ struct Manifest {
     // [lib] — library root interface convention (M5.x+).
     LibConfig                          lib;
 
+    // [workspace] — multi-package workspace.
+    WorkspaceConfig                    workspace;
+
     // M5.0: post-parse computed/inferred state
     bool                        usesModules    = true;   // refined by scanner
     bool                        usesImportStd  = true;   // refined by scanner
@@ -267,22 +282,26 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
     Manifest m;
     m.sourcePath = origin;
 
-    // [package]
+    // [package] — required unless [workspace] is present (virtual workspace).
     auto* pkg_t = doc->get_table("package");
-    if (!pkg_t) return std::unexpected(error(origin, "missing required [package] section"));
+    bool has_workspace = (doc->get_table("workspace") != nullptr);
+    if (!pkg_t && !has_workspace)
+        return std::unexpected(error(origin, "missing required [package] section"));
 
     auto name = doc->get_string("package.name");
-    if (!name) return std::unexpected(error(origin, "missing required field 'package.name'"));
-    m.package.name = *name;
+    if (!name && !has_workspace)
+        return std::unexpected(error(origin, "missing required field 'package.name'"));
+    if (name) m.package.name = *name;
 
     // 0.0.6+: explicit namespace field (xpkg V1 style).
     // If present, [package].name is the short name.
     // If absent, compat.cppm::resolve_package_name infers from dotted name.
     if (auto v = doc->get_string("package.namespace")) m.package.namespace_ = *v;
 
     auto version = doc->get_string("package.version");
-    if (!version) return std::unexpected(error(origin, "missing required field 'package.version'"));
-    m.package.version = *version;
+    if (!version && !has_workspace)
+        return std::unexpected(error(origin, "missing required field 'package.version'"));
+    if (version) m.package.version = *version;
 
     if (auto v = doc->get_string("package.description")) m.package.description = *v;
     if (auto v = doc->get_string("package.license"))     m.package.license     = *v;
@@ -395,7 +414,7 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
     auto is_dep_spec_key = [](std::string_view k) {
         return k == "path"   || k == "version" || k == "git"
             || k == "rev"    || k == "tag"     || k == "branch"
-            || k == "features";
+            || k == "features" || k == "workspace";
     };
     auto looks_like_inline_dep_spec = [&](const t::Table& sub) {
         if (sub.empty()) return false;
@@ -423,6 +442,10 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
             spec.gitRev     = it->second.as_string();
             spec.gitRefKind = "branch";
         }
+        if (auto it = sub.find("workspace"); it != sub.end() && it->second.is_bool() && it->second.as_bool()) {
+            spec.inheritWorkspace = true;
+            return {};  // version will be filled in by workspace merge
+        }
         if (spec.path.empty() && spec.version.empty() && spec.git.empty()) {
             return std::unexpected(error(origin, std::format(
                 "[{}.\"{}\"] must specify 'path', 'version', or 'git'", section, fqName)));
@@ -597,6 +620,46 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
         }
     }
 
+    // [workspace] — multi-package workspace support (0.0.11+).
+    if (doc->get_table("workspace")) {
+        m.workspace.present = true;
+        if (auto v = doc->get_string_array("workspace.members"))
+            m.workspace.members = *v;
+        if (auto v = doc->get_string_array("workspace.exclude"))
+            m.workspace.exclude = *v;
+
+        // [workspace.dependencies] — versions that members inherit via .workspace = true.
+        if (auto* wdeps = doc->get_table("workspace.dependencies")) {
+            for (auto& [k, v] : *wdeps) {
+                if (v.is_string()) {
+                    DependencySpec spec;
+                    spec.version = v.as_string();
+                    if (k.find('.') != std::string::npos) {
+                        auto pos = k.find('.');
+                        spec.namespace_ = k.substr(0, pos);
+                        spec.shortName  = k.substr(pos + 1);
+                    } else {
+                        spec.namespace_ = std::string{kDefaultNamespace};
+                        spec.shortName  = k;
+                    }
+                    m.workspace.dependencies[k] = std::move(spec);
+                    continue;
+                }
+                if (!v.is_table()) continue;
+                // Namespaced subtable: [workspace.dependencies.<ns>]
+                const std::string ns = k;
+                for (auto& [sk, sv] : v.as_table()) {
+                    if (!sv.is_string()) continue;
+                    DependencySpec spec;
+                    spec.namespace_ = ns;
+                    spec.shortName  = sk;
+                    spec.version    = sv.as_string();
+                    m.workspace.dependencies[std::format("{}.{}", ns, sk)] = std::move(spec);
+                }
+            }
+        }
+    }
+
     return m;
 }
 

src/pm/dep_spec.cppm

@@ -32,6 +32,8 @@ struct DependencySpec {
     std::string                 gitRev;         // commit / tag / branch (any one)
     std::string                 gitRefKind;     // "rev" / "tag" / "branch" (for clarity)
 
+    bool                        inheritWorkspace = false;  // .workspace = true
+
     bool isPath()    const { return !path.empty(); }
     bool isGit()     const { return !git.empty(); }
     bool isVersion() const { return !isPath() && !isGit() && !version.empty(); }

tests/unit/test_manifest.cpp

@@ -330,6 +330,61 @@ package = {
     EXPECT_EQ(b.version,    "0.0.2");
 }
 
+TEST(Manifest, WorkspaceSectionParsed) {
+    constexpr auto src = R"(
+[workspace]
+members = ["libs/core", "libs/http", "apps/server"]
+exclude = ["libs/experimental"]
+
+[workspace.dependencies]
+cmdline = "0.0.2"
+
+[workspace.dependencies.compat]
+gtest = "1.15.2"
+mbedtls = "3.6.1"
+)";
+    auto m = mcpp::manifest::parse_string(src);
+    ASSERT_TRUE(m.has_value()) << m.error().format();
+    EXPECT_TRUE(m->workspace.present);
+    ASSERT_EQ(m->workspace.members.size(), 3u);
+    EXPECT_EQ(m->workspace.members[0], "libs/core");
+    EXPECT_EQ(m->workspace.members[1], "libs/http");
+    EXPECT_EQ(m->workspace.members[2], "apps/server");
+    ASSERT_EQ(m->workspace.exclude.size(), 1u);
+    EXPECT_EQ(m->workspace.exclude[0], "libs/experimental");
+    ASSERT_EQ(m->workspace.dependencies.size(), 3u);
+    auto& gt = m->workspace.dependencies.at("compat.gtest");
+    EXPECT_EQ(gt.version, "1.15.2");
+    EXPECT_EQ(gt.namespace_, "compat");
+}
+
+TEST(Manifest, WorkspaceTrueInDependency) {
+    constexpr auto src = R"(
+[package]
+name = "x"
+version = "0.1.0"
+[dependencies.compat]
+mbedtls = { workspace = true }
+)";
+    auto m = mcpp::manifest::parse_string(src);
+    ASSERT_TRUE(m.has_value()) << m.error().format();
+    auto& s = m->dependencies.at("compat.mbedtls");
+    EXPECT_TRUE(s.inheritWorkspace);
+    EXPECT_EQ(s.namespace_, "compat");
+    EXPECT_EQ(s.shortName, "mbedtls");
+}
+
+TEST(Manifest, NoWorkspaceSectionMeansNotPresent) {
+    constexpr auto src = R"(
+[package]
+name = "x"
+version = "0.1.0"
+)";
+    auto m = mcpp::manifest::parse_string(src);
+    ASSERT_TRUE(m.has_value());
+    EXPECT_FALSE(m->workspace.present);
+}
+
 TEST(Manifest, LibRootInferredFromPackageName) {
     constexpr auto src = R"(
 [package]