feat: v0.14.0 — dynamic pipeline by default + broad language packs

Dynamic pipeline (composer) is now default-on, with deterministic
language-specialist selection, critical-phase enforcement, and a safe
generic fallback for any unknown language.

- New web/rust/java/cpp language packs + shell worker/tester agents;
  language detection and QA gate now cover Go, Python, JS/TS, Rust, Java,
  C/C++, HTML, and shell.
- Workspace-aware QA gate: a stale active_pack no longer forces pytest onto
  non-Python workspaces; virtualenv/cache dirs are skipped during detection.
- Static-web entrypoint guarantee + same-file task collapse (no more
  "pile of .js files" or "7 tasks editing one file" grind).
- Go single-file (no go.mod) gofmt smoke, go vet -short fix, tester
  passed:true-in-prose tolerance.
- Live event severity levels + Studio EventLog severity UI + dynamic-pipeline
  Settings toggle + LiveView badge.
- Bump version to 0.14.0 + changelog + docs.

Author: piotrlaczkowski

AGENTS.md

@@ -292,7 +292,7 @@ Slots are user-inserted agent calls around phase anchors:
 
 ---
 
-## 5. Built-in Specialists (15 total)
+## 5. Built-in Specialists (16 total)
 
 Defined in `pkg/agents/prompts.go` + `pkg/agents/factory.go`:
 
@@ -314,9 +314,38 @@ Defined in `pkg/agents/prompts.go` + `pkg/agents/factory.go`:
 | `placeholder` | Fill placeholders / flag gaps | Yes | 14 |
 | `escalate` | Escalate arbitrator | No | 1 |
 | `memory` | Distill MEMORY.md | No | 2 |
+| `composer` | Assemble a task-specific dynamic pipeline | No | 3 |
 
 Custom agents can override any built-in by placing same-id YAML in `.slmcode/agents/`.
 
+### 5.1 Dynamic Pipeline Composition (`composer`)
+
+The **composer** specialist turns the static pipeline into a per-task pipeline.
+When `dynamic_pipeline` is enabled, the composer runs right after context/explore
+and emits a structured `Composition` that the engine applies before plan/split:
+
+- **Phases** — which of the 16 phases run for this task (disabled phases become
+  `when: never`, `enabled: false`; `init`/`skills`/`done` stay structural).
+- **Team** — which specialist is bound to each phase (coding roles have tools,
+  planning roles don't), plus per-role skills.
+- **Execute loop** — `default_role`, `reviewer`, `corrector`, `max_waves`.
+- **Slots** — extra insertable specialists around phase anchors.
+
+The composed pipeline is saved to `.slmcode/pipeline.dynamic.yaml` (inspection
+only — `pipeline.yaml` is never touched) and reported live via the `compose`
+phase. A weak/unparsable composition is non-fatal: the run falls back to the
+static pipeline.
+
+Enable via config, CLI, or Studio schema:
+
+```bash
+slmcode config set dynamic_pipeline true
+slmcode run --dynamic "add JWT auth"
+```
+
+Model lives in `pkg/composer` (`Composition`, `Parse`, `Apply`); the composer
+prompt is `PromptComposer` in `pkg/agents/prompts.go`.
+
 ---
 
 ## 6. How Stacks Work
@@ -563,6 +592,7 @@ The `/files` page shows a full recursive directory tree. Features:
 
 | Version | Key Changes |
 |---------|------------|
+| 0.14.0 | **Dynamic pipeline composition** — new `composer` specialist assembles a task-specific pipeline (phases, team, tools, skills, execute loop, slots) via `dynamic_pipeline` config / `--dynamic` CLI / Studio schema; composed pipeline saved to `.slmcode/pipeline.dynamic.yaml`; `pkg/composer` (`Composition`/`Parse`/`Apply`); non-fatal fallback to static pipeline on weak/unparsable composition |
 | 0.13.0 | Block CRUD API + Studio GUI editing (blocks/pipelines/agents/skills), agent blocks as runtime roles, default_role honored, phase gating + archived phases, language-pinned prompts (no pytest in Go runs), pipeline validation hardening, blocks new/edit/delete CLI, HTTP tests for block API, live user feedback (GUI + TUI `/feedback`, injected into next agent call), skills↔agents cross-linking in Studio, update-available notifications (TUI banner, `update --check`, `version`, `GET /api/update`, Studio banner) |
 | 0.12.2 | e2e test fixes for Vite bundle output, CI builds Studio UI before Go, Homebrew formula sync, docs refresh |
 | 0.12.1 | Vite/React/TypeScript Studio UI (`web/` + `make ui-react`), `fast_model` dual-model routing, smarter QA gate, improved tester |

Makefile

@@ -1,6 +1,6 @@
 MODULE := github.com/UnicoLab/slmcode
 BIN    := slmcode
-VERSION ?= 0.13.1
+VERSION ?= 0.14.0
 PREFIX ?= $(HOME)/.local
 GIT_COMMIT := $(shell git rev-parse --short HEAD 2>/dev/null || echo unknown)
 BUILD_TIME := $(shell date -u +%Y-%m-%dT%H:%M:%SZ)

cmd/slmcode/cmd_core.go

@@ -65,9 +65,16 @@ func runCmd() *cobra.Command {
 			mode, _ := cmd.Flags().GetString("mode")
 			agent, _ := cmd.Flags().GetString("agent")
 			pinSkills, _ := cmd.Flags().GetStringSlice("skill")
+			dynamic, _ := cmd.Flags().GetBool("dynamic")
+			noDynamic, _ := cmd.Flags().GetBool("no-dynamic")
 			if mode != "" {
 				h.Config.Mode = mode
 			}
+			if dynamic {
+				h.Config.DynamicPipeline = true
+			} else if noDynamic {
+				h.Config.DynamicPipeline = false
+			}
 			if agent != "" {
 				h.Config.Specialist = agent
 				h.Config.Mode = config.ModeSpecialist
@@ -90,6 +97,9 @@ func runCmd() *cobra.Command {
 			if h.Config.Mode == config.ModeSpecialist {
 				cli.KeyVal("specialist", h.Config.Specialist)
 			}
+			if h.Config.DynamicPipeline {
+				cli.KeyVal("dynamic", "composer assembles a task-specific pipeline")
+			}
 			cli.KeyVal("think", fmt.Sprintf("%d passes", h.Config.ThinkPasses))
 			cli.KeyVal("parallel", fmt.Sprintf("%d", h.Config.MaxParallel))
 			fmt.Println()
@@ -125,6 +135,8 @@ func runCmd() *cobra.Command {
 	}
 	cmd.Flags().String("mode", "", "full | specialist (overrides config)")
 	cmd.Flags().String("agent", "", "run a single specialist (worker, explorer, …)")
+	cmd.Flags().Bool("dynamic", false, "run the composer specialist to assemble a task-specific pipeline (default: on)")
+	cmd.Flags().Bool("no-dynamic", false, "disable the dynamic pipeline (use the static pipeline)")
 	cmd.Flags().StringSlice("skill", nil, "pin/load skill by name (repeatable); also accepts @skill:name in query")
 	return cmd
 }

cmd/slmcode/cmd_util.go

@@ -195,6 +195,7 @@ func configCmd() *cobra.Command {
 			cli.KeyVal("backend", c.Backend)
 			cli.KeyVal("mode", c.Mode)
 			cli.KeyVal("specialist", c.Specialist)
+			cli.KeyVal("dynamic_pipeline", fmt.Sprintf("%v", c.DynamicPipeline))
 			cli.KeyVal("pinned_skills", strings.Join(c.PinnedSkills, ", "))
 			cli.KeyVal("think_passes", fmt.Sprintf("%d", c.ThinkPasses))
 			cli.KeyVal("max_parallel", fmt.Sprintf("%d", c.MaxParallel))
@@ -243,6 +244,8 @@ func configCmd() *cobra.Command {
 				if v != "" {
 					c.Mode = config.ModeSpecialist
 				}
+			case "dynamic_pipeline", "dynamic", "composer":
+				c.DynamicPipeline = v == "1" || strings.EqualFold(v, "true") || strings.EqualFold(v, "yes") || strings.EqualFold(v, "on")
 			case "pinned_skills", "skills":
 				if v == "" || v == "-" {
 					c.PinnedSkills = nil

cmd/slmcode/ui/index.html

@@ -8,8 +8,8 @@
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet" />
     <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'><rect width='32' height='32' rx='6' fill='%237c3aed'/><text x='16' y='22' font-family='system-ui' font-weight='700' font-size='18' fill='white' text-anchor='middle'>SL</text></svg>" />
-    <script type="module" crossorigin src="/assets/index-BJBYh-fV.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CHgA9IM9.css">
+    <script type="module" crossorigin src="/assets/index-B5L19IV9.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Djv6tf4Z.css">
   </head>
   <body class="antialiased">
     <div id="root"></div>

cmd/slmcode/version.go

@@ -4,7 +4,7 @@ package main
 //
 //	go build -ldflags "-X main.Version=0.5.0 -X main.SourceRoot=/path -X main.GitCommit=abc -X main.BuildTime=…"
 var (
-	Version    = "0.13.1"
+	Version    = "0.14.0"
 	SourceRoot = "" // absolute path to the slmcode checkout used to build this binary
 	GitCommit  = "unknown"
 	BuildTime  = "unknown"

docs/agents.md

@@ -1,6 +1,6 @@
 # 🧩 Agents
 
-Fourteen specialists. Scoped packs. No “hold the monorepo in your head” cosplay. 🎭
+Sixteen specialists. Scoped packs. No “hold the monorepo in your head” cosplay. 🎭
 
 <div class="slm-banner" markdown>
 <span class="slm-banner__emoji">🧬</span>
@@ -32,6 +32,7 @@ see <a href="providers.md">Providers</a>. Budget diplomacy is a feature.
 | `placeholder` | ✅ + `find_models` / `mcp_call` | status + gaps | Fill stubs / flag precise gaps 🩹 |
 | `escalate` | — | action JSON | HITL timeout arbitrator (retry/re-scope/…) ⚖️ |
 | `memory` | — | bullets | Learn 💾 |
+| `composer` | — | pipeline JSON | Assemble a task-specific pipeline (dynamic_pipeline) 🎯 |
 
 !!! note "🧰 Coding tools"
     Coding agents share `ws_*` + `git_*` plus **`find_models`** (auth-gated catalog)

docs/architecture.md

@@ -31,6 +31,7 @@ If you stuff the whole repo into context, don’t be surprised when the model na
 cmd/slmcode          CLI + embedded Studio (go:embed ui/)
 pkg/orchestrator     Pipeline runner + coordinator + sessions
 pkg/pipeline         Config-driven phases / slots / loop agents
+pkg/composer         Dynamic pipeline composition (Composition/Parse/Apply)
 pkg/blocks           Building block registry + bundled YAML presets
 pkg/loop             Parallel execute → review → correct
 pkg/agents           Specialist prompts + custom YAML factory

docs/blocks.md

@@ -95,6 +95,52 @@ Pipeline: react  | Agents: react-worker, react-tester   | Quality: react
 - **Tester**: `npm run lint` → `tsc --noEmit` → `npm test` → `npm run build`
 - **QA Gate**: `npm test --silent`
 
+### 🌐 Static Web (HTML/CSS/JS)
+
+```
+Pipeline: web  | Agents: web-worker, web-tester   | Quality: web
+```
+
+- **Pipeline**: Static-browser-aware with `web-tester` agent
+- **Worker**: Always produces a usable `index.html` entrypoint + referenced assets
+- **Tester**: Verifies a non-empty HTML entrypoint, resolved asset refs, `node --check` each `.js`
+- **QA Gate**: non-empty `.html` entrypoint exists (no pytest / npm test forced)
+
+### 🦀 Rust
+
+```
+Pipeline: rust  | Agents: rust-worker, rust-tester   | Quality: rust
+```
+
+- **Worker**: cargo module-aware, smokes with `cargo build --quiet`
+- **Tester**: `cargo build` → `cargo test` → `cargo clippy` (optional)
+- **QA Gate**: `cargo test --quiet`
+
+### ☕ Java
+
+```
+Pipeline: java  | Agents: java-worker, java-tester   | Quality: java
+```
+
+- **Worker**: Maven/Gradle-aware, smokes with `mvn -q -DskipTests compile`
+- **Tester**: `mvn -q test` (or `./gradlew test`)
+- **QA Gate**: `mvn -q test`
+
+### ⚙️ C/C++
+
+```
+Pipeline: cpp  | Agents: cpp-worker, cpp-tester   | Quality: cpp
+```
+
+- **Worker**: CMake/Make-aware, smokes with `cmake --build build`
+- **Tester**: `cmake --build build` → `ctest` (when present)
+- **QA Gate**: `cmake --build build`
+
+### 🐚 Shell (agents only)
+
+`shell-worker` / `shell-tester` — for Bash/shell scripts (`bash -n` + `shellcheck`).
+No standalone pack; the generic pipeline selects them when the workspace is shell.
+
 ---
 
 ## CLI Commands

docs/changelog.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## v0.14.0 — Dynamic Pipeline, Broad Language Support & Live Log Severity
+
+### Highlights
+- **Dynamic pipeline is now the default** — the `composer` specialist assembles a
+  task-specific pipeline (phases, team, tools, skills) before every run; disable via
+  `dynamic_pipeline: false`, `slmcode run --no-dynamic`, or the Studio Settings toggle.
+  The composer deterministically upgrades generic `worker`/`tester` to the matching
+  language specialist, enforces that `execute` + `test` always run, and falls back to a
+  safe generic pipeline for any unknown language.
+- **Six new language packs** — `web` (static HTML/CSS/JS), `rust`, `java`, `cpp`
+  (full pipeline + quality + worker/tester), plus `shell` worker/tester agents.
+  `DetectProjectLanguage`/`langHint`/splitter guidance now cover Go, Python, JS/TS,
+  Rust, Java, C/C++, HTML, and shell.
+- **Static-web deliverables are guaranteed** — HTML/browser/game queries always get an
+  `index.html` (or the splitter's chosen `.html`) entrypoint injected; a pile of
+  disconnected `.js` files with no page can no longer happen.
+- **QA gate is workspace-aware** — a stale `active_pack` (e.g. `python` from a prior
+  run) no longer forces pytest onto a Go/JS/HTML workspace; virtualenv/cache dirs are
+  skipped during quality detection; a lone `.go` file without `go.mod` uses a
+  module-free `gofmt -e` smoke, and the `go test`→`go vet` fast-path no longer emits
+  an invalid `-short` flag.
+- **Live log severity** — events now carry a `level` (`info|warning|error|success|problem`);
+  the Studio Event Log renders severity badges, colors, and a Problems filter with
+  error/warning/success counts.
+- **Tester finalize is more forgiving** — an explicit `passed:true` anywhere in the
+  finalize (not just inside the parsed JSON object) is now honored, reducing false
+  "missing passed:true" rejections.
+- **Same-file task collapse** — many worker tasks editing one self-contained file are
+  collapsed into a single worker (fixes the "7 tasks editing index.html" grind that
+  caused review/correction loops).
+- **Shell whitelist** extended for cargo/mvn/gradle/ctest/gcc/clang/shellcheck.
+
 ## v0.13.1 — 2026-08-10
 
 - Automate Homebrew formula checksum sync in the release pipeline