diff --git a/internal/webui/handlers_control_test.go b/internal/webui/handlers_control_test.go
index 18d3970a..7abc6ffd 100644
--- a/internal/webui/handlers_control_test.go
+++ b/internal/webui/handlers_control_test.go
@@ -689,6 +689,175 @@ func TestHandleForkPoints_WithCheckpoints(t *testing.T) {
}
}
+// --- Start Pipeline with advanced options tests ---
+
+func TestHandleStartPipeline_WithModel(t *testing.T) {
+ srv, _ := testServer(t)
+ setupPipelineDir(t, "test-pipeline", []string{"step1", "step2"})
+
+ body := strings.NewReader(`{"input":"test","model":"haiku"}`)
+ req := httptest.NewRequest("POST", "/api/pipelines/test-pipeline/start", body)
+ req.SetPathValue("name", "test-pipeline")
+ req.Header.Set("Content-Type", "application/json")
+ rec := httptest.NewRecorder()
+ srv.handleStartPipeline(rec, req)
+
+ if rec.Code != http.StatusCreated {
+ t.Fatalf("expected 201, got %d: %s", rec.Code, rec.Body.String())
+ }
+
+ var resp StartPipelineResponse
+ if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
+ t.Fatalf("failed to decode response: %v", err)
+ }
+ if resp.PipelineName != "test-pipeline" {
+ t.Errorf("expected pipeline name 'test-pipeline', got %q", resp.PipelineName)
+ }
+ if resp.Status != "running" {
+ t.Errorf("expected status 'running', got %q", resp.Status)
+ }
+}
+
+func TestHandleStartPipeline_WithSteps(t *testing.T) {
+ srv, _ := testServer(t)
+ setupPipelineDir(t, "test-pipeline", []string{"step1", "step2", "step3"})
+
+ body := strings.NewReader(`{"input":"test","steps":"step1,step3"}`)
+ req := httptest.NewRequest("POST", "/api/pipelines/test-pipeline/start", body)
+ req.SetPathValue("name", "test-pipeline")
+ req.Header.Set("Content-Type", "application/json")
+ rec := httptest.NewRecorder()
+ srv.handleStartPipeline(rec, req)
+
+ if rec.Code != http.StatusCreated {
+ t.Fatalf("expected 201, got %d: %s", rec.Code, rec.Body.String())
+ }
+}
+
+func TestHandleStartPipeline_WithExclude(t *testing.T) {
+ srv, _ := testServer(t)
+ setupPipelineDir(t, "test-pipeline", []string{"step1", "step2", "step3"})
+
+ body := strings.NewReader(`{"input":"test","exclude":"step2"}`)
+ req := httptest.NewRequest("POST", "/api/pipelines/test-pipeline/start", body)
+ req.SetPathValue("name", "test-pipeline")
+ req.Header.Set("Content-Type", "application/json")
+ rec := httptest.NewRecorder()
+ srv.handleStartPipeline(rec, req)
+
+ if rec.Code != http.StatusCreated {
+ t.Fatalf("expected 201, got %d: %s", rec.Code, rec.Body.String())
+ }
+}
+
+func TestHandleStartPipeline_DryRun(t *testing.T) {
+ srv, _ := testServer(t)
+ setupPipelineDir(t, "test-pipeline", []string{"step1", "step2"})
+
+ body := strings.NewReader(`{"input":"test","dry_run":true}`)
+ req := httptest.NewRequest("POST", "/api/pipelines/test-pipeline/start", body)
+ req.SetPathValue("name", "test-pipeline")
+ req.Header.Set("Content-Type", "application/json")
+ rec := httptest.NewRecorder()
+ srv.handleStartPipeline(rec, req)
+
+ if rec.Code != http.StatusCreated {
+ t.Fatalf("expected 201 for dry-run, got %d: %s", rec.Code, rec.Body.String())
+ }
+
+ var resp StartPipelineResponse
+ if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
+ t.Fatalf("failed to decode response: %v", err)
+ }
+ if resp.PipelineName != "test-pipeline" {
+ t.Errorf("expected pipeline name 'test-pipeline', got %q", resp.PipelineName)
+ }
+}
+
+func TestHandleStartPipeline_DryRunCreatesCompletedRun(t *testing.T) {
+ srv, rwStore := testServer(t)
+ setupPipelineDir(t, "test-pipeline", []string{"step1", "step2"})
+
+ body := strings.NewReader(`{"input":"test","dry_run":true}`)
+ req := httptest.NewRequest("POST", "/api/pipelines/test-pipeline/start", body)
+ req.SetPathValue("name", "test-pipeline")
+ req.Header.Set("Content-Type", "application/json")
+ rec := httptest.NewRecorder()
+ srv.handleStartPipeline(rec, req)
+
+ if rec.Code != http.StatusCreated {
+ t.Fatalf("expected 201 for dry-run, got %d: %s", rec.Code, rec.Body.String())
+ }
+
+ // Dry-run creates a run
+ runs, err := rwStore.ListRuns(state.ListRunsOptions{Limit: 10})
+ if err != nil {
+ t.Fatalf("failed to list runs: %v", err)
+ }
+ if len(runs) != 1 {
+ t.Fatalf("expected 1 run after dry-run, got %d", len(runs))
+ }
+}
+
+// --- SubmitRun with advanced options tests ---
+
+func TestHandleSubmitRun_WithModel(t *testing.T) {
+ srv, _ := testServer(t)
+ setupPipelineDir(t, "test-pipeline", []string{"step1", "step2"})
+
+ body := strings.NewReader(`{"pipeline":"test-pipeline","input":"test","model":"opus"}`)
+ req := httptest.NewRequest("POST", "/api/runs", body)
+ req.Header.Set("Content-Type", "application/json")
+ rec := httptest.NewRecorder()
+ srv.handleSubmitRun(rec, req)
+
+ if rec.Code != http.StatusCreated {
+ t.Fatalf("expected 201, got %d: %s", rec.Code, rec.Body.String())
+ }
+
+ var resp SubmitRunResponse
+ if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
+ t.Fatalf("failed to decode response: %v", err)
+ }
+ if resp.PipelineName != "test-pipeline" {
+ t.Errorf("expected pipeline 'test-pipeline', got %q", resp.PipelineName)
+ }
+}
+
+func TestHandleSubmitRun_DryRun(t *testing.T) {
+ srv, rwStore := testServer(t)
+ setupPipelineDir(t, "test-pipeline", []string{"step1", "step2"})
+
+ body := strings.NewReader(`{"pipeline":"test-pipeline","input":"test","dry_run":true}`)
+ req := httptest.NewRequest("POST", "/api/runs", body)
+ req.Header.Set("Content-Type", "application/json")
+ rec := httptest.NewRecorder()
+ srv.handleSubmitRun(rec, req)
+
+ if rec.Code != http.StatusCreated {
+ t.Fatalf("expected 201 for dry-run, got %d: %s", rec.Code, rec.Body.String())
+ }
+
+ var resp SubmitRunResponse
+ if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
+ t.Fatalf("failed to decode response: %v", err)
+ }
+ if resp.PipelineName != "test-pipeline" {
+ t.Errorf("expected pipeline name 'test-pipeline', got %q", resp.PipelineName)
+ }
+
+ // Dry-run creates a run
+ runs, err := rwStore.ListRuns(state.ListRunsOptions{Limit: 10})
+ if err != nil {
+ t.Fatalf("failed to list runs: %v", err)
+ }
+ if len(runs) != 1 {
+ t.Fatalf("expected 1 run after dry-run, got %d", len(runs))
+ }
+}
+
+// --- buildExecOptions / buildStepFilter tests ---
+
func TestIsHeartbeat(t *testing.T) {
tests := []struct {
name string
diff --git a/internal/webui/templates/pipeline_detail.html b/internal/webui/templates/pipeline_detail.html
index 89bf1a75..c78d48f9 100644
--- a/internal/webui/templates/pipeline_detail.html
+++ b/internal/webui/templates/pipeline_detail.html
@@ -113,6 +113,42 @@ Start Pipeline: Input (optional)
+
+ Advanced Options
+
+ Model Override
+
+ Default (auto)
+ Haiku
+ Sonnet
+ Opus
+
+
+
+ Resume From Step
+
+ Start from beginning
+
+
+
+
+
+
+
+
+
Cancel
Start
@@ -127,6 +163,15 @@
Start Pipeline: Start Pipeline: No steps ';
+ var exclHTML = '';
+ for (var i = 0; i < steps.length; i++) {
+ exclHTML += 'No steps ';
+ }).catch(function() {
+ if (stepsChecks) stepsChecks.innerHTML = 'Failed to load steps ';
+ if (excludeChecks) excludeChecks.innerHTML = 'Failed to load steps ';
+ });
+}
+
+function onQsFromStepChange() {
+ var fromStep = document.getElementById('qs-from-step');
+ var stepsGroup = document.getElementById('qs-steps-group');
+ if (fromStep && fromStep.value) {
+ if (stepsGroup) stepsGroup.style.opacity = '0.5';
+ var checks = document.querySelectorAll('#qs-steps-checks input[type="checkbox"]');
+ for (var i = 0; i < checks.length; i++) { checks[i].checked = false; checks[i].disabled = true; }
+ } else {
+ if (stepsGroup) stepsGroup.style.opacity = '1';
+ var checks = document.querySelectorAll('#qs-steps-checks input[type="checkbox"]');
+ for (var i = 0; i < checks.length; i++) { checks[i].disabled = false; }
+ }
+}
+
document.addEventListener('keydown', function(e) {
if (e.key === 'Escape') hideQuickStart();
});
diff --git a/internal/webui/templates/pipelines.html b/internal/webui/templates/pipelines.html
index 538c25e0..8a64bb85 100644
--- a/internal/webui/templates/pipelines.html
+++ b/internal/webui/templates/pipelines.html
@@ -68,6 +68,42 @@ Start Pipeline: Input (optional)
+
+ Advanced Options
+
+ Model Override
+
+ Default (auto)
+ Haiku
+ Sonnet
+ Opus
+
+
+
+ Resume From Step
+
+ Start from beginning
+
+
+
+
+
+
+
+
+
Cancel
Start
@@ -82,6 +118,15 @@
Start Pipeline: Start Pipeline: No steps ';
+ var exclHTML = '';
+ for (var i = 0; i < steps.length; i++) {
+ exclHTML += 'No steps ';
+ }).catch(function() {
+ if (stepsChecks) stepsChecks.innerHTML = 'Failed to load steps ';
+ if (excludeChecks) excludeChecks.innerHTML = 'Failed to load steps ';
+ });
+}
+
+function onQsFromStepChange() {
+ var fromStep = document.getElementById('qs-from-step');
+ var stepsGroup = document.getElementById('qs-steps-group');
+ if (fromStep && fromStep.value) {
+ if (stepsGroup) stepsGroup.style.opacity = '0.5';
+ var checks = document.querySelectorAll('#qs-steps-checks input[type="checkbox"]');
+ for (var i = 0; i < checks.length; i++) { checks[i].checked = false; checks[i].disabled = true; }
+ } else {
+ if (stepsGroup) stepsGroup.style.opacity = '1';
+ var checks = document.querySelectorAll('#qs-steps-checks input[type="checkbox"]');
+ for (var i = 0; i < checks.length; i++) { checks[i].disabled = false; }
+ }
+}
+
// Set category badges from pipeline name prefix on load
document.querySelectorAll('#pipeline-tbody tr').forEach(function(row) {
var name = row.dataset.name || '';
diff --git a/specs/690-webui-start-flags/plan.md b/specs/690-webui-start-flags/plan.md
new file mode 100644
index 00000000..248e89db
--- /dev/null
+++ b/specs/690-webui-start-flags/plan.md
@@ -0,0 +1,72 @@
+# Implementation Plan: WebUI Start Pipeline Dialog Flags
+
+## Objective
+
+Expose the five high-priority CLI flags (`--model`, `--from-step`, `--steps`, `--exclude`, `--dry-run`) in the web UI's "Start Pipeline" dialog so users can configure pipeline runs without the CLI. Step lists must be dynamically populated from the pipeline definition.
+
+## Approach
+
+The implementation touches three layers: **types** (request struct), **handlers** (wiring to executor options), and **UI** (templates + JS). There are three distinct start dialogs that need updating:
+
+1. **Runs page** (`runs.html`) — full dialog with pipeline selector + new controls
+2. **Pipelines list page** (`pipelines.html`) — quickstart dialog (pipeline is pre-selected)
+3. **Pipeline detail page** (`pipeline_detail.html`) — quickstart dialog (pipeline is pre-selected)
+
+The existing `GET /api/pipelines/{name}` endpoint already returns step IDs, personas, and dependencies — this will be used to populate step dropdowns dynamically when a pipeline is selected.
+
+### Key Design Decisions
+
+1. **Collapsible "Advanced Options" section**: The five new controls go into a collapsible `` element below the Input field. This keeps the dialog simple for basic use while exposing power-user controls on demand.
+
+2. **Step selection via checkboxes, not multi-select**: Multi-select `` elements are notoriously hard to use. Use checkbox lists that appear after pipeline selection, populated from the API.
+
+3. **Dry-run returns a validation report**: When `dry_run: true`, the handler runs `DryRunValidator.Validate()` and returns the report as JSON instead of launching execution. The UI shows the report inline.
+
+4. **from-step is separate from steps/exclude**: `from-step` means "resume from this step onward" (sequential). `steps` means "run only these specific steps". They serve different purposes but are mutually exclusive in the UI.
+
+5. **Both `StartPipelineRequest` and `SubmitRunRequest` need updating**: The runs page uses `handleSubmitRun` (POST /api/runs), while pipelines pages use `handleStartPipeline` (POST /api/pipelines/{name}/start). Both need the new fields.
+
+## File Mapping
+
+### Modify
+
+| File | Changes |
+|------|---------|
+| `internal/webui/types.go` | Add `Model`, `FromStep`, `Steps`, `Exclude`, `DryRun` fields to `StartPipelineRequest` and `SubmitRunRequest`. Add `DryRunResponse` type. |
+| `internal/webui/handlers_control.go` | Wire new request fields into `ExecutorOption` list in `launchPipelineExecution`. Add dry-run branch in `handleStartPipeline` and `handleSubmitRun`. |
+| `internal/webui/templates/runs.html` | Add collapsible "Advanced Options" section with model dropdown, from-step dropdown, steps/exclude checkboxes, dry-run toggle. Add JS to populate step lists on pipeline select. |
+| `internal/webui/templates/pipelines.html` | Expand quickstart dialog with same advanced options. Pipeline is pre-selected so step lists load immediately. |
+| `internal/webui/templates/pipeline_detail.html` | Expand quickstart dialog with same advanced options. Pipeline is pre-selected so step lists load immediately. |
+| `internal/webui/static/app.js` | Update `startPipeline()` to collect and send new fields. Add `loadPipelineSteps()` helper. Update `submitQuickStart()` pattern in templates. |
+
+### No New Files Needed
+
+All changes fit within existing files. No new packages, no new routes (the existing `GET /api/pipelines/{name}` provides step data).
+
+## Architecture Decisions
+
+1. **Reuse existing API**: `GET /api/pipelines/{name}` already returns `PipelineDetail` with step IDs. No new endpoint needed for step population.
+
+2. **Executor options via `launchPipelineExecution`**: The shared launch function already builds `[]pipeline.ExecutorOption`. We add conditional appends for model, timeout, step filter, and auto-approve — mirroring what `cmd/wave/commands/run.go` does.
+
+3. **Dry-run is validation-only**: The CLI's `--dry-run` runs `DryRunValidator.Validate()` and prints a report. The web UI does the same but returns JSON. No pipeline execution occurs.
+
+4. **from-step creates a new run**: Consistent with how `handleResumeRun` works — creates a new run record and calls `launchPipelineExecution` with the fromStep parameter. The difference is this is for a fresh pipeline start (not resuming a failed run), so we skip the "must be failed/cancelled" check.
+
+5. **Model dropdown values**: `""` (default/auto), `"haiku"`, `"sonnet"`, `"opus"`. These match what the CLI accepts and what `resolveModel()` processes.
+
+## Risks
+
+| Risk | Mitigation |
+|------|-----------|
+| Step IDs contain special characters | Step IDs are already validated by pipeline YAML loading; safe to use in HTML attributes |
+| from-step + steps are mutually exclusive | UI disables steps/exclude when from-step is set, and vice versa. Handler validates mutual exclusivity. |
+| Dry-run for pipelines with template vars | `DryRunValidator` already handles template vars gracefully (warns but doesn't error). Return warnings in response. |
+| Quickstart dialogs diverge from main dialog | Extract shared JS function `collectAdvancedOptions()` used by all three dialogs |
+
+## Testing Strategy
+
+1. **Unit tests for handler changes**: Test `handleStartPipeline` with each new field (model, from-step, steps, exclude, dry-run). Verify executor options are correctly built.
+2. **Unit tests for dry-run response**: Test that dry-run returns validation report and does NOT create a run record.
+3. **Unit tests for mutual exclusivity**: Test that from-step + steps returns a 400 error.
+4. **Integration verification**: Manual testing of all three dialogs (runs page, pipelines list, pipeline detail) to confirm step lists populate and options are sent correctly.
diff --git a/specs/690-webui-start-flags/spec.md b/specs/690-webui-start-flags/spec.md
new file mode 100644
index 00000000..be56d948
--- /dev/null
+++ b/specs/690-webui-start-flags/spec.md
@@ -0,0 +1,41 @@
+# feat(webui): start pipeline dialog missing CLI flags (model, from-step, steps, exclude, dry-run)
+
+**Issue**: [re-cinq/wave#690](https://github.com/re-cinq/wave/issues/690)
+**Parent**: #687 (item 3)
+**Author**: nextlevelshit
+**Complexity**: medium
+
+## Problem
+
+The "Start Pipeline" dialog on `/pipelines` and `/runs` only has an Input text field. The `StartPipelineRequest` struct only has `Input string`. The CLI `wave run` supports 18+ flags that are invisible in the web UI.
+
+## Required Flags (High Priority)
+
+- `--model` — model override dropdown (haiku/sonnet/opus)
+- `--from-step` — resume from specific step (dropdown of step IDs)
+- `--steps` — run only named steps (multi-select)
+- `--exclude` / `-x` — skip named steps (multi-select)
+- `--dry-run` — preview checkbox
+
+## Nice to Have
+
+- `--timeout` — timeout in minutes
+- `--on-failure` — halt or skip radio
+- `--auto-approve` — checkbox for gate auto-approval
+
+## Files to Change
+
+- `internal/webui/types.go` — expand `StartPipelineRequest`
+- `internal/webui/handlers_control.go` — wire new fields into executor options
+- `internal/webui/templates/pipelines.html` — add form fields to the start dialog
+- `internal/webui/static/app.js` or inline JS — send new fields in the API call
+
+## Acceptance Criteria
+
+- [ ] Start dialog shows model dropdown, from-step, steps, exclude, dry-run toggle
+- [ ] Selected options are sent in the API request and applied to execution
+- [ ] Step lists are populated from the pipeline definition (loaded via API)
+
+## Labels
+
+None
diff --git a/specs/690-webui-start-flags/tasks.md b/specs/690-webui-start-flags/tasks.md
new file mode 100644
index 00000000..1196b65d
--- /dev/null
+++ b/specs/690-webui-start-flags/tasks.md
@@ -0,0 +1,32 @@
+# Tasks
+
+## Phase 1: Backend Types and Handler Wiring
+
+- [X] Task 1.1: Expand `StartPipelineRequest` and `SubmitRunRequest` with new fields (`Model`, `FromStep`, `Steps`, `Exclude`, `DryRun`) in `internal/webui/types.go`. Add `DryRunResponse` type for dry-run results.
+- [X] Task 1.2: Wire new fields into executor options in `handleStartPipeline` — add conditional `WithModelOverride`, `WithStepFilter`, and `WithStepTimeout` appends. Add from-step support via `launchPipelineExecution`. Validate mutual exclusivity of `from-step` vs `steps`.
+- [X] Task 1.3: Wire same fields into `handleSubmitRun` (POST /api/runs) — same logic as 1.2 but for the runs page submit path.
+- [X] Task 1.4: Implement dry-run branch in both handlers — when `DryRun` is true, run `DryRunValidator.Validate()` and return the report as JSON without creating a run record.
+
+## Phase 2: Frontend — Runs Page Dialog
+
+- [X] Task 2.1: Add collapsible "Advanced Options" `` section to the start dialog in `runs.html` with: model dropdown (auto/haiku/sonnet/opus), from-step dropdown, steps checkboxes, exclude checkboxes, dry-run toggle.
+- [X] Task 2.2: Add JS in `runs.html` to call `GET /api/pipelines/{name}` on pipeline selection and populate step dropdowns/checkboxes from the response. Disable steps/exclude when from-step is set and vice versa.
+- [X] Task 2.3: Update `startPipeline()` in `app.js` to collect and include new fields in the API request body. Handle dry-run response (show validation report instead of redirecting).
+
+## Phase 3: Frontend — Quickstart Dialogs [P]
+
+- [X] Task 3.1: Expand quickstart dialog in `pipelines.html` with advanced options. Load step list on dialog open (pipeline is already known). [P]
+- [X] Task 3.2: Expand quickstart dialog in `pipeline_detail.html` with advanced options. Load step list on dialog open (pipeline is already known). [P]
+- [X] Task 3.3: Update `submitQuickStart()` in both templates to collect and send new fields. Handle dry-run response. [P]
+
+## Phase 4: Testing
+
+- [X] Task 4.1: Write unit tests for `handleStartPipeline` with new fields — model override, step filter, from-step, dry-run. [P]
+- [X] Task 4.2: Write unit tests for `handleSubmitRun` with new fields. [P]
+- [X] Task 4.3: Write unit tests for mutual exclusivity validation (from-step + steps = 400 error). [P]
+- [X] Task 4.4: Write unit test for dry-run response (returns report, no run created). [P]
+
+## Phase 5: Polish
+
+- [X] Task 5.1: Run `go test ./...` and `go vet ./...` to ensure no regressions.
+- [ ] Task 5.2: Manual verification of all three dialogs (runs, pipelines list, pipeline detail).