Jrs add shared service groups

.gitignore

@@ -1,4 +1,5 @@
 /target
+/target-cov
 lcov.info
 .env
 

Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "coast-i18n",
     "coast-secrets",
     "coast-docker",
+    "coast-ssg",
     "coast-daemon",
     "coast-cli",
     "coast-update",

coast-cli/src/commands/build.rs

@@ -378,26 +378,49 @@ impl ProgressDisplay {
     }
 }
 
+/// Validate a user-supplied `--type <coastfile_type>` argument.
+///
+/// Rejects:
+/// - `default` / `toml` — reserved degenerate names.
+/// - SSG variants (`shared_service_groups`) — built via `coast ssg build`,
+///   not through this command. See `coast-ssg/DESIGN.md`.
+///
+/// Remote variants (`remote*`) are intentionally NOT rejected here:
+/// `coast build --type remote.foo` is a valid invocation that the
+/// downstream pipeline handles. Only SSG is fundamentally incompatible
+/// with `coast build`.
+pub(crate) fn validate_coastfile_type_arg(t: &str) -> Result<()> {
+    if t == "default" {
+        bail!(
+            "'--type default' is not allowed. \
+             The base 'Coastfile' is the default type. \
+             Run 'coast build' without --type."
+        );
+    }
+    if t == "toml" {
+        bail!(
+            "'--type toml' is not allowed. \
+             'toml' is a reserved name. Use 'Coastfile.toml' for the default type \
+             with syntax highlighting, or choose a different type name."
+        );
+    }
+    if coast_core::coastfile::Coastfile::is_ssg_type(Some(t)) {
+        bail!(
+            "'--type {t}' is a Shared Service Group variant; \
+             build it with 'coast ssg build' instead of 'coast build --type {t}'. \
+             SSGs are a separate build product (see coast-ssg/DESIGN.md)."
+        );
+    }
+    Ok(())
+}
+
 /// Execute the `coast build` command.
 ///
 /// The project name is derived from the Coastfile, not from the `--project` flag,
 /// since the Coastfile itself defines the project name.
 pub async fn execute(args: &BuildArgs, global_working_dir: &Option<PathBuf>) -> Result<()> {
     if let Some(ref t) = args.coastfile_type {
-        if t == "default" {
-            bail!(
-                "'--type default' is not allowed. \
-                 The base 'Coastfile' is the default type. \
-                 Run 'coast build' without --type."
-            );
-        }
-        if t == "toml" {
-            bail!(
-                "'--type toml' is not allowed. \
-                 'toml' is a reserved name. Use 'Coastfile.toml' for the default type \
-                 with syntax highlighting, or choose a different type name."
-            );
-        }
+        validate_coastfile_type_arg(t.as_str())?;
     }
 
     let has_inline_flags = args.project_name.is_some()
@@ -759,6 +782,46 @@ mod tests {
         assert_eq!(cli.args.coastfile_path, PathBuf::from("my/Coastfile"));
     }
 
+    // -------------------------------------------------------------------
+    // validate_coastfile_type_arg tests
+    // -------------------------------------------------------------------
+
+    #[test]
+    fn test_validate_coastfile_type_arg_rejects_default() {
+        let err = validate_coastfile_type_arg("default").unwrap_err();
+        assert!(err.to_string().contains("'--type default' is not allowed"));
+    }
+
+    #[test]
+    fn test_validate_coastfile_type_arg_rejects_toml() {
+        let err = validate_coastfile_type_arg("toml").unwrap_err();
+        assert!(err.to_string().contains("'--type toml' is not allowed"));
+    }
+
+    #[test]
+    fn test_validate_coastfile_type_arg_rejects_shared_service_groups() {
+        let err = validate_coastfile_type_arg("shared_service_groups").unwrap_err();
+        let msg = err.to_string();
+        assert!(
+            msg.contains("Shared Service Group"),
+            "expected SSG mention, got: {msg}"
+        );
+        assert!(
+            msg.contains("coast ssg build"),
+            "expected pointer to 'coast ssg build', got: {msg}"
+        );
+    }
+
+    #[test]
+    fn test_validate_coastfile_type_arg_accepts_user_variants() {
+        assert!(validate_coastfile_type_arg("light").is_ok());
+        assert!(validate_coastfile_type_arg("e2e").is_ok());
+        // Remote variants pass through `validate_coastfile_type_arg` —
+        // they're handled downstream by the remote-build pipeline.
+        assert!(validate_coastfile_type_arg("remote").is_ok());
+        assert!(validate_coastfile_type_arg("remote.light").is_ok());
+    }
+
     // -------------------------------------------------------------------
     // ProgressDisplay state-machine tests
     // -------------------------------------------------------------------

coast-cli/src/commands/mod.rs

@@ -36,6 +36,7 @@ pub mod search_docs;
 pub mod secret;
 pub mod shared;
 pub mod skills_prompt;
+pub mod ssg;
 pub mod start;
 pub mod stop;
 pub mod ui;
@@ -301,13 +302,85 @@ async fn send_build_request_to(
             Response::RerunExtractorsProgress(ref event) => {
                 on_progress(event);
             }
+            Response::SsgProgress(ref event) => {
+                on_progress(event);
+            }
             _ => {
                 return Ok(response);
             }
         }
     }
 }
 
+/// Stream `coast ssg logs --follow` output chunks to a callback.
+///
+/// Connects to the daemon, sends the request, then reads `SsgLogChunk`
+/// responses in a loop, invoking `on_chunk` for each one. The final
+/// `Ssg(SsgResponse)` (or `Error`) closes the stream.
+pub async fn stream_ssg_log_chunks(request: Request, mut on_chunk: impl FnMut(&str)) -> Result<()> {
+    let sock = socket_path();
+    let stream = UnixStream::connect(&sock).await.map_err(|e| {
+        if e.kind() == std::io::ErrorKind::ConnectionRefused
+            || e.kind() == std::io::ErrorKind::NotFound
+        {
+            anyhow::anyhow!("{}", t!("error.daemon_not_running"))
+        } else {
+            anyhow::anyhow!(
+                "{}",
+                t!(
+                    "error.daemon_connect_failed",
+                    path = sock.display(),
+                    message = e
+                )
+            )
+        }
+    })?;
+
+    let (reader, mut writer) = stream.into_split();
+
+    let encoded = protocol::encode_request(&request).context("Failed to encode request")?;
+    writer
+        .write_all(&encoded)
+        .await
+        .context("Failed to send request to coastd")?;
+    writer
+        .shutdown()
+        .await
+        .context("Failed to flush request to coastd")?;
+
+    let mut buf_reader = BufReader::new(reader);
+
+    loop {
+        let mut line = String::new();
+        let bytes = buf_reader
+            .read_line(&mut line)
+            .await
+            .context("Failed to read response from coastd")?;
+
+        if bytes == 0 {
+            return Ok(());
+        }
+
+        let response = protocol::decode_response(line.trim_end().as_bytes())
+            .context("Failed to decode response from coastd")?;
+
+        match response {
+            Response::SsgLogChunk(chunk) => {
+                on_chunk(&chunk.chunk);
+            }
+            Response::Ssg(_) => {
+                return Ok(());
+            }
+            Response::Error(e) => {
+                bail!("{}", e.error);
+            }
+            other => {
+                bail!("unexpected response from daemon while tailing SSG logs: {other:?}");
+            }
+        }
+    }
+}
+
 /// Send a run request and stream progress events to a callback.
 ///
 /// Connects to the daemon, sends the request, then reads JSON lines in a loop.