diff --git a/.codex/skills/qa-night-shift/SKILL.md b/.codex/skills/qa-night-shift/SKILL.md
index a6af37d..6845cf0 100644
--- a/.codex/skills/qa-night-shift/SKILL.md
+++ b/.codex/skills/qa-night-shift/SKILL.md
@@ -143,6 +143,10 @@ Typical flow:
 12. after `resolve -> continue` on a setup blocker, confirm `status`,
    `report`, and Dash still show the retry-armed state and keep confidence
    below `high` until the next `night-shift start` consumes the waiver
+13. when the user specifically wants the browser surface, use
+   `night-shift dash`, then drive `start`, `resume`, and `resolve` from the
+   browser-backed HTTP/UI flow instead of the removed `dash --start`,
+   `dash --resume`, `start --ui`, or `resume --ui` entrypoints
 
 For review-driven investigations, replace steps 3-4 with:
 
diff --git a/.codex/skills/update-local-night-shift-cli/SKILL.md b/.codex/skills/update-local-night-shift-cli/SKILL.md
index d3faaf3..97c890d 100644
--- a/.codex/skills/update-local-night-shift-cli/SKILL.md
+++ b/.codex/skills/update-local-night-shift-cli/SKILL.md
@@ -10,10 +10,13 @@ run the code from a specific worktree.
 
 ## What this skill does
 
-- Builds the selected worktree with `gleam build`.
+- Builds the selected worktree with `gleam build` and `scripts/build_dash_assets.sh`.
 - Creates a versioned install bundle under `~/.local/share/night-shift/<label>`.
 - Copies the compiled Erlang package directories from `build/dev/erlang/`.
+- Copies the built dashboard assets from `build/dash-assets/`.
 - Writes stable `entrypoint.sh` and `entrypoint.ps1` launchers into that bundle.
+- Exports `NIGHT_SHIFT_DASH_ASSET_ROOT` from the launcher so `night-shift dash`
+  works from the installed bundle.
 - Repoints `~/.local/share/night-shift/current` to the new bundle.
 - Ensures `~/.local/bin/night-shift` exists and launches `current/entrypoint.sh run`.
 - Smoke-tests the install through the normal `night-shift` launcher.
diff --git a/.codex/skills/update-local-night-shift-cli/scripts/install_local_cli.sh b/.codex/skills/update-local-night-shift-cli/scripts/install_local_cli.sh
index 655f4dd..fd2d8db 100755
--- a/.codex/skills/update-local-night-shift-cli/scripts/install_local_cli.sh
+++ b/.codex/skills/update-local-night-shift-cli/scripts/install_local_cli.sh
@@ -53,6 +53,7 @@ fi
 
 SOURCE_DIR="$(cd "$SOURCE_DIR" && pwd)"
 BUILD_DIR="$SOURCE_DIR/build/dev/erlang"
+DASH_ASSET_DIR="$SOURCE_DIR/build/dash-assets"
 
 if [ ! -f "$SOURCE_DIR/gleam.toml" ]; then
   echo "Not a Gleam project: $SOURCE_DIR" >&2
@@ -62,6 +63,7 @@ fi
 (
   cd "$SOURCE_DIR"
   gleam build
+  sh ./scripts/build_dash_assets.sh "$DASH_ASSET_DIR"
 )
 
 if [ ! -d "$BUILD_DIR" ]; then
@@ -69,6 +71,11 @@ if [ ! -d "$BUILD_DIR" ]; then
   exit 1
 fi
 
+if [ ! -d "$DASH_ASSET_DIR" ]; then
+  echo "Missing dashboard assets: $DASH_ASSET_DIR" >&2
+  exit 1
+fi
+
 if [ -z "$LABEL" ]; then
   if LABEL="$(git -C "$SOURCE_DIR" rev-parse --short HEAD 2>/dev/null)"; then
     :
@@ -88,6 +95,8 @@ for package_dir in "$BUILD_DIR"/*; do
   fi
 done
 
+cp -R "$DASH_ASSET_DIR" "$INSTALL_DIR"/dash-assets
+
 cat > "$INSTALL_DIR/entrypoint.sh" <<'EOF'
 #!/bin/sh
 set -eu
@@ -97,6 +106,7 @@ BASE=$(CDPATH= cd -- "$(dirname "$0")" && pwd)
 COMMAND="${1-default}"
 
 run() {
+  NIGHT_SHIFT_DASH_ASSET_ROOT="$BASE/dash-assets" \
   exec erl \
     -pa "$BASE"/*/ebin \
     -eval "$PACKAGE@@main:run($PACKAGE)" \
@@ -137,6 +147,7 @@ $Command = if ($args.Count -gt 0) { $args[0] } else { "run" }
 switch ($Command) {
   "run" {
     $Remaining = if ($args.Count -gt 1) { $args[1..($args.Count - 1)] } else { @() }
+    $env:NIGHT_SHIFT_DASH_ASSET_ROOT = "$Base/dash-assets"
     & erl -pa "$Base/*/ebin" -eval "$Package@@main:run($Package)" -noshell -extra @Remaining
   }
   "shell" {
diff --git a/README.md b/README.md
index 81d02ab..e19abef 100644
--- a/README.md
+++ b/README.md
@@ -21,7 +21,7 @@ Night Shift already has working support for:
 - provider adapters for Codex CLI and Cursor Agent
 - local verification before pull request delivery
 - review-loop ingestion for open Night Shift pull requests
-- a local monitor-only dashboard via `start --ui` and `resume --ui`
+- a repo-local Dash front door via `night-shift dash`
 
 The current operator flow is:
 
@@ -126,10 +126,10 @@ night-shift resume --explain
 night-shift resume
 ```
 
-If you want the local dashboard while a run is active:
+If you want the browser front door for planning, execution, and audit:
 
 ```sh
-night-shift start --ui
+night-shift dash
 ```
 
 ## Source Development
diff --git a/dash_web/gleam.toml b/dash_web/gleam.toml
new file mode 100644
index 0000000..0d13866
--- /dev/null
+++ b/dash_web/gleam.toml
@@ -0,0 +1,8 @@
+name = "dash_web"
+version = "0.1.0"
+target = "javascript"
+
+[dependencies]
+gleam_stdlib = ">= 0.44.0 and < 2.0.0"
+gleam_json = ">= 3.1.0 and < 4.0.0"
+lustre = ">= 5.3.0 and < 6.0.0"
diff --git a/dash_web/manifest.toml b/dash_web/manifest.toml
new file mode 100644
index 0000000..be40bf5
--- /dev/null
+++ b/dash_web/manifest.toml
@@ -0,0 +1,16 @@
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "gleam_erlang", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "1124AD3AA21143E5AF0FC5CF3D9529F6DB8CA03E43A55711B60B6B7B3874375C" },
+  { name = "gleam_json", version = "3.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_json", source = "hex", outer_checksum = "44FDAA8847BE8FC48CA7A1C089706BD54BADCC4C45B237A992EDDF9F2CDB2836" },
+  { name = "gleam_otp", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "BA6A294E295E428EC1562DC1C11EA7530DCB981E8359134BEABC8493B7B2258E" },
+  { name = "gleam_stdlib", version = "0.71.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "702F3BC2A14793906880B1078B19A6165F87323AEE8D0C4A34085846336FCAAE" },
+  { name = "houdini", version = "1.2.0", build_tools = ["gleam"], requirements = [], otp_app = "houdini", source = "hex", outer_checksum = "5DB1053F1AF828049C2B206D4403C18970ABEF5C18671CA3C2D2ED0DD64F6385" },
+  { name = "lustre", version = "5.6.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_json", "gleam_otp", "gleam_stdlib", "houdini"], otp_app = "lustre", source = "hex", outer_checksum = "EE558CD4DB9F09FCC16417ADF0183A3C2DAC3E4B21ED3AC0CAE859792AB810CA" },
+]
+
+[requirements]
+gleam_json = { version = ">= 3.1.0 and < 4.0.0" }
+gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
+lustre = { version = ">= 5.3.0 and < 6.0.0" }
diff --git a/dash_web/src/browser_ffi.mjs b/dash_web/src/browser_ffi.mjs
new file mode 100644
index 0000000..40e41e0
--- /dev/null
+++ b/dash_web/src/browser_ffi.mjs
@@ -0,0 +1,71 @@
+let activeSource = null;
+
+export function initialRunTarget() {
+  const root = document.querySelector("#app");
+  const value = root?.dataset?.initialRun ?? "";
+  return value.length > 0 ? value : "latest";
+}
+
+function respond(response, onSuccess, onError) {
+  response
+    .text()
+    .then((text) => {
+      if (response.ok) {
+        onSuccess(text);
+      } else {
+        onError(text || `Request failed: ${response.status}`);
+      }
+    })
+    .catch((error) => onError(String(error)));
+}
+
+export function fetchWorkspace(targetRun, onSuccess, onError) {
+  const suffix =
+    targetRun && targetRun !== "latest"
+      ? `?run=${encodeURIComponent(targetRun)}`
+      : "";
+  fetch(`/api/workspace${suffix}`, { cache: "no-store" })
+    .then((response) => respond(response, onSuccess, onError))
+    .catch((error) => onError(String(error)));
+}
+
+export function fetchModels(provider, onSuccess, onError) {
+  fetch(`/api/init/models?provider=${encodeURIComponent(provider)}`, {
+    cache: "no-store",
+  })
+    .then((response) => respond(response, onSuccess, onError))
+    .catch((error) => onError(String(error)));
+}
+
+export function postJson(path, payload, onSuccess, onError) {
+  fetch(path, {
+    method: "POST",
+    cache: "no-store",
+    headers: { "content-type": "application/json" },
+    body: payload,
+  })
+    .then((response) => respond(response, onSuccess, onError))
+    .catch((error) => onError(String(error)));
+}
+
+export function openEventStream(targetRun, onOpen, onMessage, onError) {
+  if (activeSource) {
+    activeSource.close();
+  }
+
+  const runId = targetRun && targetRun.length > 0 ? targetRun : "latest";
+  const source = new EventSource(`/api/runs/${encodeURIComponent(runId)}/events`);
+  activeSource = source;
+
+  source.onopen = () => {
+    onOpen("connected");
+  };
+
+  source.onmessage = (event) => {
+    onMessage(event.data);
+  };
+
+  source.onerror = () => {
+    onError("disconnected");
+  };
+}
diff --git a/dash_web/src/dash_web.gleam b/dash_web/src/dash_web.gleam
new file mode 100644
index 0000000..185749c
--- /dev/null
+++ b/dash_web/src/dash_web.gleam
@@ -0,0 +1,2045 @@
+import gleam/dynamic/decode
+import gleam/int
+import gleam/json
+import gleam/list
+import gleam/option.{type Option, None, Some}
+import gleam/result
+import gleam/string
+import lustre
+import lustre/attribute
+import lustre/effect
+import lustre/element/html
+import lustre/event
+
+@external(javascript, "./browser_ffi.mjs", "fetchWorkspace")
+fn fetch_workspace_raw(
+  target_run: String,
+  on_success: fn(String) -> Nil,
+  on_error: fn(String) -> Nil,
+) -> Nil
+
+@external(javascript, "./browser_ffi.mjs", "fetchModels")
+fn fetch_models_raw(
+  provider: String,
+  on_success: fn(String) -> Nil,
+  on_error: fn(String) -> Nil,
+) -> Nil
+
+@external(javascript, "./browser_ffi.mjs", "postJson")
+fn post_json_raw(
+  path: String,
+  payload: String,
+  on_success: fn(String) -> Nil,
+  on_error: fn(String) -> Nil,
+) -> Nil
+
+@external(javascript, "./browser_ffi.mjs", "openEventStream")
+fn open_event_stream_raw(
+  target_run: String,
+  on_open: fn(String) -> Nil,
+  on_message: fn(String) -> Nil,
+  on_error: fn(String) -> Nil,
+) -> Nil
+
+@external(javascript, "./browser_ffi.mjs", "initialRunTarget")
+fn initial_run_target() -> String
+
+pub fn main() -> Nil {
+  let app = lustre.application(init, update, view)
+  let _ = lustre.start(app, "#app", Nil)
+  Nil
+}
+
+type Model {
+  Model(
+    workspace: Option(Workspace),
+    connection: String,
+    selected_run: String,
+    selected_task: Option(String),
+    active_tab: String,
+    init_form: InitForm,
+    plan_form: PlanForm,
+    decision_answers: List(#(String, String)),
+    notice: Option(Notice),
+    last_stream_target: String,
+  )
+}
+
+type Notice {
+  Notice(kind: String, message: String)
+}
+
+type InitForm {
+  InitForm(
+    provider: String,
+    model: String,
+    reasoning: String,
+    generate_setup: Bool,
+    models: List(ProviderModel),
+  )
+}
+
+type PlanForm {
+  PlanForm(notes: String, doc_path: String)
+}
+
+type Workspace {
+  Workspace(
+    repo_root: String,
+    initialized: Bool,
+    default_profile: String,
+    providers: List(String),
+    runs: List(RunSummary),
+    selected_run_id: Option(String),
+    command_state: Option(CommandState),
+    run: Option(RunView),
+  )
+}
+
+type RunSummary {
+  RunSummary(
+    run_id: String,
+    status: String,
+    created_at: String,
+    updated_at: String,
+    task_count: Int,
+  )
+}
+
+type CommandState {
+  CommandState(
+    name: String,
+    run_id: Option(String),
+    started_at: String,
+    summary: String,
+  )
+}
+
+type RunView {
+  RunView(
+    run_id: String,
+    status: String,
+    created_at: String,
+    updated_at: String,
+    next_action: String,
+    planning_label: String,
+    uses_reviews: Bool,
+    notes_label: String,
+    confidence_level: String,
+    confidence_reasons: List(String),
+    tasks: List(TaskView),
+    dag_nodes: List(DagNode),
+    dag_edges: List(DagEdge),
+    decisions: List(PendingDecision),
+    repo_state: Option(RepoStateView),
+    timeline: List(TimelineEntry),
+    report_markdown: String,
+    provenance_markdown: String,
+    delivery: List(DeliveryView),
+    setup_blocker: Option(RecoveryBlocker),
+    implementation_blockers: List(TaskView),
+    report_url: String,
+    provenance_url: String,
+  )
+}
+
+type DagNode {
+  DagNode(
+    id: String,
+    title: String,
+    state: String,
+    kind: String,
+    branch_name: String,
+    pr_number: String,
+    pr_url: Option(String),
+  )
+}
+
+type DagEdge {
+  DagEdge(from: String, to: String)
+}
+
+type TaskView {
+  TaskView(
+    id: String,
+    title: String,
+    description: String,
+    summary: String,
+    state: String,
+    kind: String,
+    execution_mode: String,
+    dependencies: List(String),
+    acceptance: List(String),
+    demo_plan: List(String),
+    branch_name: String,
+    pr_number: String,
+    pr_url: Option(String),
+    superseded_pr_numbers: List(Int),
+    worktree_path: String,
+    task_log_url: String,
+    verify_log_url: String,
+  )
+}
+
+type PendingDecision {
+  PendingDecision(task_id: String, task_title: String, request: DecisionRequest)
+}
+
+type DecisionRequest {
+  DecisionRequest(
+    key: String,
+    question: String,
+    rationale: String,
+    options: List(DecisionOption),
+    recommended_option: Option(String),
+    allow_freeform: Bool,
+  )
+}
+
+type DecisionOption {
+  DecisionOption(label: String, description: String)
+}
+
+type RepoStateView {
+  RepoStateView(
+    snapshot_captured_at: String,
+    drift: String,
+    actionable_pull_requests: List(PullRequestView),
+    impacted_pull_requests: List(PullRequestView),
+    replacement_lineage: List(LineageView),
+  )
+}
+
+type PullRequestView {
+  PullRequestView(number: Int, title: String, branch_name: String, url: String)
+}
+
+type LineageView {
+  LineageView(
+    task_id: String,
+    superseded_pr_numbers: List(Int),
+    replacement_pr_number: Option(String),
+  )
+}
+
+type TimelineEntry {
+  TimelineEntry(
+    kind: String,
+    at: String,
+    message: String,
+    task_id: Option(String),
+  )
+}
+
+type DeliveryView {
+  DeliveryView(
+    task_id: String,
+    task_title: String,
+    pr_number: String,
+    pr_url: String,
+  )
+}
+
+type RecoveryBlocker {
+  RecoveryBlocker(
+    kind: String,
+    phase: String,
+    task_id: Option(String),
+    message: String,
+    log_path: String,
+    disposition: String,
+  )
+}
+
+type ProviderModel {
+  ProviderModel(id: String, label: String, is_default: Bool)
+}
+
+type ActionResponse {
+  ActionResponse(summary: String, next_action: String, run_id: Option(String))
+}
+
+type Msg {
+  WorkspaceLoaded(String)
+  WorkspaceLoadFailed(String)
+  StreamOpened
+  StreamMessage(String)
+  StreamErrored
+  SelectRun(String)
+  SelectTask(String)
+  SelectTab(String)
+  UpdateInitProvider(String)
+  UpdateInitModel(String)
+  UpdateInitReasoning(String)
+  ToggleGenerateSetup(Bool)
+  ModelsLoaded(String)
+  ModelsLoadFailed(String)
+  SubmitInit
+  UpdateNotes(String)
+  UpdateDocPath(String)
+  SubmitPlan
+  SubmitPlanFromReviews
+  StartRun
+  ResumeRun
+  UpdateDecisionAnswer(String, String)
+  SubmitDecisions
+  RecoveryAction(String, Option(String))
+  ActionSucceeded(String)
+  ActionFailed(String)
+}
+
+fn init(_) -> #(Model, effect.Effect(Msg)) {
+  let target_run = initial_run_target()
+  let init_form =
+    InitForm(
+      provider: "codex",
+      model: "",
+      reasoning: "",
+      generate_setup: False,
+      models: [],
+    )
+  #(
+    Model(
+      workspace: None,
+      connection: "connecting",
+      selected_run: target_run,
+      selected_task: None,
+      active_tab: "graph",
+      init_form: init_form,
+      plan_form: PlanForm(notes: "", doc_path: ""),
+      decision_answers: [],
+      notice: None,
+      last_stream_target: "",
+    ),
+    effect.batch([
+      fetch_workspace_effect(target_run),
+      open_stream_effect(target_run),
+      fetch_models_effect("codex"),
+    ]),
+  )
+}
+
+fn update(model: Model, msg: Msg) -> #(Model, effect.Effect(Msg)) {
+  case msg {
+    WorkspaceLoaded(payload) ->
+      case decode_workspace(payload) {
+        Ok(workspace) -> {
+          let selected_task =
+            resolve_selected_task(model.selected_task, workspace)
+          let next_stream_target =
+            selected_run_target(workspace.selected_run_id)
+          let tab = suggest_tab(model.active_tab, workspace)
+          let next_model =
+            Model(
+              ..model,
+              workspace: Some(workspace),
+              selected_run: next_stream_target,
+              selected_task: selected_task,
+              active_tab: tab,
+              connection: "connected",
+            )
+          let stream_effect = case
+            next_stream_target != model.last_stream_target
+          {
+            True -> open_stream_effect(next_stream_target)
+            False -> effect.none()
+          }
+          #(
+            Model(..next_model, last_stream_target: next_stream_target),
+            stream_effect,
+          )
+        }
+        Error(message) -> #(
+          Model(..model, notice: Some(Notice("error", message))),
+          effect.none(),
+        )
+      }
+    WorkspaceLoadFailed(message) -> #(
+      Model(
+        ..model,
+        connection: "disconnected",
+        notice: Some(Notice("error", message)),
+      ),
+      effect.none(),
+    )
+    StreamOpened -> #(Model(..model, connection: "connected"), effect.none())
+    StreamMessage(_) -> #(model, fetch_workspace_effect(model.selected_run))
+    StreamErrored -> #(
+      Model(..model, connection: "disconnected"),
+      effect.none(),
+    )
+    SelectRun(run_id) -> #(
+      Model(
+        ..model,
+        selected_run: run_id,
+        selected_task: None,
+        active_tab: "graph",
+      ),
+      effect.batch([fetch_workspace_effect(run_id), open_stream_effect(run_id)]),
+    )
+    SelectTask(task_id) -> #(
+      Model(..model, selected_task: Some(task_id)),
+      effect.none(),
+    )
+    SelectTab(tab) -> #(
+      Model(..model, active_tab: tab),
+      effect.none(),
+    )
+    UpdateInitProvider(provider) -> #(
+      Model(
+        ..model,
+        init_form: InitForm(
+          ..model.init_form,
+          provider: provider,
+          model: "",
+          models: [],
+        ),
+      ),
+      fetch_models_effect(provider),
+    )
+    UpdateInitModel(value) -> #(
+      Model(..model, init_form: InitForm(..model.init_form, model: value)),
+      effect.none(),
+    )
+    UpdateInitReasoning(value) -> #(
+      Model(..model, init_form: InitForm(..model.init_form, reasoning: value)),
+      effect.none(),
+    )
+    ToggleGenerateSetup(value) -> #(
+      Model(
+        ..model,
+        init_form: InitForm(..model.init_form, generate_setup: value),
+      ),
+      effect.none(),
+    )
+    ModelsLoaded(payload) ->
+      case decode_models(payload) {
+        Ok(models) -> {
+          let selected = default_model_id(models, model.init_form.model)
+          #(
+            Model(
+              ..model,
+              init_form: InitForm(
+                ..model.init_form,
+                models: models,
+                model: selected,
+              ),
+            ),
+            effect.none(),
+          )
+        }
+        Error(message) -> #(
+          Model(..model, notice: Some(Notice("error", message))),
+          effect.none(),
+        )
+      }
+    ModelsLoadFailed(message) -> #(
+      Model(..model, notice: Some(Notice("error", message))),
+      effect.none(),
+    )
+    SubmitInit -> #(
+      model,
+      post_effect("/api/init", init_payload(model.init_form)),
+    )
+    UpdateNotes(value) -> #(
+      Model(..model, plan_form: PlanForm(..model.plan_form, notes: value)),
+      effect.none(),
+    )
+    UpdateDocPath(value) -> #(
+      Model(..model, plan_form: PlanForm(..model.plan_form, doc_path: value)),
+      effect.none(),
+    )
+    SubmitPlan -> #(
+      model,
+      post_effect("/api/plans", plan_payload(model.plan_form)),
+    )
+    SubmitPlanFromReviews -> #(
+      model,
+      post_effect("/api/plans/from-reviews", plan_payload(model.plan_form)),
+    )
+    StartRun ->
+      case selected_run(model.workspace) {
+        Some(run) -> #(
+          model,
+          post_effect("/api/runs/" <> run.run_id <> "/start", "{}"),
+        )
+        None -> #(model, effect.none())
+      }
+    ResumeRun ->
+      case selected_run(model.workspace) {
+        Some(run) -> #(
+          model,
+          post_effect("/api/runs/" <> run.run_id <> "/resume", "{}"),
+        )
+        None -> #(model, effect.none())
+      }
+    UpdateDecisionAnswer(key, value) -> #(
+      Model(
+        ..model,
+        decision_answers: put_answer(model.decision_answers, key, value),
+      ),
+      effect.none(),
+    )
+    SubmitDecisions ->
+      case selected_run(model.workspace) {
+        Some(run) -> #(
+          model,
+          post_effect(
+            "/api/runs/" <> run.run_id <> "/resolve/decisions",
+            decisions_payload(model.decision_answers, run.decisions),
+          ),
+        )
+        None -> #(model, effect.none())
+      }
+    RecoveryAction(action, task_id) ->
+      case selected_run(model.workspace) {
+        Some(run) -> #(
+          model,
+          post_effect(
+            "/api/runs/" <> run.run_id <> "/recovery/" <> action,
+            recovery_payload(task_id),
+          ),
+        )
+        None -> #(model, effect.none())
+      }
+    ActionSucceeded(payload) ->
+      case decode_action_response(payload) {
+        Ok(response) -> #(
+          Model(
+            ..model,
+            notice: Some(Notice(
+              "success",
+              response.summary <> " Next: " <> response.next_action,
+            )),
+          ),
+          fetch_workspace_effect(model.selected_run),
+        )
+        Error(message) -> #(
+          Model(..model, notice: Some(Notice("error", message))),
+          effect.none(),
+        )
+      }
+    ActionFailed(message) -> #(
+      Model(..model, notice: Some(Notice("error", message))),
+      effect.none(),
+    )
+  }
+}
+
+fn view(model: Model) {
+  html.div([attribute.class("shell")], [
+    topbar_view(model),
+    html.div([attribute.class("body")], [
+      sidebar_view(model),
+      main_content_view(model),
+    ]),
+  ])
+}
+
+fn topbar_view(model: Model) {
+  html.header([attribute.class("topbar")], [
+    html.div([attribute.class("topbar-brand")], [
+      html.h1([], [html.text("Night Shift")]),
+      case model.workspace {
+        Some(workspace) ->
+          html.span([attribute.class("repo-root")], [
+            html.text(workspace.repo_root),
+          ])
+        None -> html.text("")
+      },
+    ]),
+    html.div([attribute.class("topbar-meta")], [
+      html.div([attribute.class("meta-card")], [
+        html.span([attribute.class("meta-label")], [html.text("Connection")]),
+        html.span([attribute.class("meta-value")], [
+          html.span(
+            [attribute.class("connection-dot " <> model.connection)],
+            [],
+          ),
+          html.text(model.connection),
+        ]),
+      ]),
+      meta_card("Run", model.selected_run),
+      meta_card("Command", case active_command(model.workspace) {
+        Some(command) -> command.name <> " @ " <> command.started_at
+        None -> "idle"
+      }),
+    ]),
+  ])
+}
+
+fn sidebar_view(model: Model) {
+  html.aside([attribute.class("sidebar")], [
+    workspace_section(model),
+    runs_section(model),
+  ])
+}
+
+fn workspace_section(model: Model) {
+  html.div([attribute.class("sidebar-section")], case model.workspace {
+    Some(workspace) ->
+      case workspace.initialized {
+        True -> [
+          html.p([attribute.class("nav-title")], [html.text("Planning")]),
+          plan_form_view(model),
+        ]
+        False -> [
+          html.p([attribute.class("nav-title")], [html.text("Initialize")]),
+          html.p([attribute.class("muted")], [
+            html.text("Configure provider, model, and setup."),
+          ]),
+          init_form_view(model, workspace.providers),
+        ]
+      }
+    None -> [
+      html.p([attribute.class("muted")], [html.text("Loading workspace...")]),
+    ]
+  })
+}
+
+fn runs_section(model: Model) {
+  html.div([attribute.class("sidebar-section")], [
+    html.p([attribute.class("nav-title")], [html.text("Runs")]),
+    html.ul([attribute.class("run-list")], case model.workspace {
+      Some(workspace) ->
+        case workspace.runs {
+          [] -> [
+            html.li([], [
+              html.span([attribute.class("muted")], [
+                html.text("No runs yet."),
+              ]),
+            ]),
+          ]
+          runs -> runs |> list.map(run_button(_, model.selected_run))
+        }
+      None -> [
+        html.li([], [
+          html.span([attribute.class("muted")], [
+            html.text("Loading..."),
+          ]),
+        ]),
+      ]
+    }),
+  ])
+}
+
+fn run_button(run: RunSummary, selected_run: String) {
+  html.li([], [
+    html.button(
+      [
+        attribute.class(
+          "run-link"
+          <> case run.run_id == selected_run {
+            True -> " active"
+            False -> ""
+          },
+        ),
+        event.on_click(SelectRun(run.run_id)),
+      ],
+      [
+        html.span(
+          [attribute.class("status-dot status-" <> run.status)],
+          [],
+        ),
+        html.span([attribute.class("run-info")], [
+          html.span([attribute.class("run-id")], [html.text(run.run_id)]),
+          html.span([attribute.class("run-meta")], [
+            html.text(
+              run.status
+              <> " · "
+              <> int_to_string(run.task_count)
+              <> " tasks",
+            ),
+          ]),
+        ]),
+      ],
+    ),
+  ])
+}
+
+fn init_form_view(model: Model, providers: List(String)) {
+  html.div([attribute.class("sidebar-form")], [
+    select_field(
+      "Provider",
+      providers,
+      model.init_form.provider,
+      UpdateInitProvider,
+    ),
+    select_models_field(model.init_form.models, model.init_form.model),
+    text_field(
+      "Reasoning",
+      "low | medium | high | xhigh",
+      model.init_form.reasoning,
+      UpdateInitReasoning,
+    ),
+    checkbox_field(
+      "Generate setup from provider",
+      model.init_form.generate_setup,
+    ),
+    html.button(
+      [attribute.class("btn btn-primary btn-sm"), event.on_click(SubmitInit)],
+      [html.text("Initialize")],
+    ),
+  ])
+}
+
+fn plan_form_view(model: Model) {
+  html.div([attribute.class("sidebar-form")], [
+    html.textarea(
+      [
+        attribute.placeholder("Paste planning notes or a short operator brief"),
+        attribute.value(model.plan_form.notes),
+        event.on_input(UpdateNotes),
+      ],
+      model.plan_form.notes,
+    ),
+    text_field(
+      "Doc path",
+      "./notes.md",
+      model.plan_form.doc_path,
+      UpdateDocPath,
+    ),
+    html.div([attribute.class("button-row")], [
+      html.button(
+        [attribute.class("btn btn-primary btn-sm"), event.on_click(SubmitPlan)],
+        [html.text("Plan")],
+      ),
+      html.button(
+        [attribute.class("btn btn-sm"), event.on_click(SubmitPlanFromReviews)],
+        [html.text("From Reviews")],
+      ),
+    ]),
+  ])
+}
+
+fn main_content_view(model: Model) {
+  html.section([attribute.class("main-area")], [
+    notice_view(model.notice),
+    case model.workspace {
+      Some(workspace) ->
+        case workspace.run {
+          Some(run) ->
+            html.div([], [
+              run_bar_view(run),
+              tab_strip_view(model.active_tab, run),
+              tab_content_view(model.active_tab, run, model.selected_task,
+                model.decision_answers),
+            ])
+          None ->
+            html.div([attribute.class("empty-state")], [
+              html.p([], [
+                html.text("No run selected. Plan work from the sidebar to begin."),
+              ]),
+            ])
+        }
+      None ->
+        html.div([attribute.class("empty-state")], [
+          html.p([], [html.text("Loading workspace...")]),
+        ])
+    },
+  ])
+}
+
+fn run_bar_view(run: RunView) {
+  html.div([attribute.class("run-bar")], [
+    html.div([attribute.class("run-bar-info")], [
+      html.span([attribute.class("run-id-label")], [html.text(run.run_id)]),
+      html.span([attribute.class("status-badge " <> run.status)], [
+        html.text(run.status),
+      ]),
+      html.span([attribute.class("next-action")], [
+        html.text(run.next_action),
+      ]),
+    ]),
+    html.div([attribute.class("run-bar-meta")], [
+      meta_card("Planning", run.planning_label),
+      meta_card("Confidence", run.confidence_level),
+      meta_card("Updated", run.updated_at),
+    ]),
+    html.div([attribute.class("run-bar-actions")], [
+      html.button(
+        [attribute.class("btn btn-primary btn-sm"), event.on_click(StartRun)],
+        [html.text("Start")],
+      ),
+      html.button(
+        [attribute.class("btn btn-sm"), event.on_click(ResumeRun)],
+        [html.text("Resume")],
+      ),
+    ]),
+  ])
+}
+
+fn tab_strip_view(active_tab: String, run: RunView) {
+  let decision_count = list.length(run.decisions)
+  let blocker_count =
+    list.length(run.implementation_blockers)
+    + case run.setup_blocker {
+      Some(_) -> 1
+      None -> 0
+    }
+  html.nav([attribute.class("tab-strip")], [
+    tab_button("graph", "Graph", active_tab, 0),
+    tab_button("timeline", "Timeline", active_tab, 0),
+    tab_button("decisions", "Decisions", active_tab, decision_count),
+    tab_button("recovery", "Recovery", active_tab, blocker_count),
+    tab_button("report", "Report", active_tab, 0),
+    tab_button("provenance", "Provenance", active_tab, 0),
+    tab_button("delivery", "Delivery", active_tab, 0),
+    case run.repo_state {
+      Some(_) -> tab_button("repo_state", "Repo State", active_tab, 0)
+      None -> html.text("")
+    },
+  ])
+}
+
+fn tab_button(id: String, label: String, active_tab: String, badge: Int) {
+  html.button(
+    [
+      attribute.class(
+        "tab-btn"
+        <> case id == active_tab {
+          True -> " active"
+          False -> ""
+        },
+      ),
+      event.on_click(SelectTab(id)),
+    ],
+    case badge > 0 {
+      True -> [
+        html.text(label),
+        html.span([attribute.class("tab-badge warn")], [
+          html.text(int_to_string(badge)),
+        ]),
+      ]
+      False -> [html.text(label)]
+    },
+  )
+}
+
+fn tab_content_view(
+  active_tab: String,
+  run: RunView,
+  selected_task_id: Option(String),
+  decision_answers: List(#(String, String)),
+) {
+  html.div([attribute.class("tab-content")], [
+    case active_tab {
+      "graph" -> graph_tab(run, selected_task_id)
+      "timeline" -> timeline_panel(run)
+      "decisions" -> decision_panel(run, decision_answers)
+      "recovery" -> recovery_panel(run)
+      "report" ->
+        markdown_panel("Report", run.report_markdown, run.report_url)
+      "provenance" ->
+        markdown_panel(
+          "Provenance",
+          run.provenance_markdown,
+          run.provenance_url,
+        )
+      "delivery" -> delivery_panel(run)
+      "repo_state" -> repo_state_panel(run)
+      _ -> graph_tab(run, selected_task_id)
+    },
+  ])
+}
+
+fn graph_tab(run: RunView, selected_task_id: Option(String)) {
+  html.div([attribute.class("graph-split")], [
+    dag_panel(run, selected_task_id),
+    task_panel(run, selected_task_id),
+  ])
+}
+
+fn dag_panel(run: RunView, selected_task_id: Option(String)) {
+  html.div([], [
+    html.h2([], [html.text("Task Graph")]),
+    html.div(
+      [attribute.class("dag-graph")],
+      run.dag_nodes
+        |> list.map(fn(node) {
+          let layer = node_layer(node.id, run.tasks)
+          html.button(
+            [
+              attribute.class(
+                "dag-node state-"
+                <> node.state
+                <> case selected_task_id == Some(node.id) {
+                  True -> " active"
+                  False -> ""
+                },
+              ),
+              attribute.style("grid-column", layer),
+              event.on_click(SelectTask(node.id)),
+            ],
+            [
+              html.span([attribute.class("node-title")], [
+                html.text(node.title),
+              ]),
+              html.span([attribute.class("node-state")], [
+                html.text(node.state),
+              ]),
+            ],
+          )
+        }),
+    ),
+  ])
+}
+
+fn task_panel(run: RunView, selected_task_id: Option(String)) {
+  html.div([], [
+    html.h2([], [html.text("Task Detail")]),
+    case selected_task(run.tasks, selected_task_id) {
+      Some(task) ->
+        html.div([attribute.class("task-detail")], [
+          html.h3([], [html.text(task.title)]),
+          html.p([attribute.class("muted")], [
+            html.text(task.id <> " · " <> task.state <> " · " <> task.kind),
+          ]),
+          html.p([], [html.text(non_empty(task.summary, task.description))]),
+          detail_line("Task log", Some(task.task_log_url), ""),
+          detail_line("Verify log", Some(task.verify_log_url), ""),
+          text_line("Worktree", task.worktree_path),
+          text_line("Branch", task.branch_name),
+          maybe_link_line("PR", task.pr_url, task.pr_number),
+          text_line("Supersedes", render_pr_numbers(task.superseded_pr_numbers)),
+        ])
+      None ->
+        html.p([attribute.class("muted")], [
+          html.text("Select a task to inspect its details."),
+        ])
+    },
+  ])
+}
+
+fn decision_panel(run: RunView, answers: List(#(String, String))) {
+  html.div([], [
+    html.h2([], [html.text("Resolve Decisions")]),
+    case run.decisions {
+      [] ->
+        html.p([attribute.class("muted")], [
+          html.text("No unresolved planning decisions."),
+        ])
+      decisions ->
+        html.div(
+          [],
+          list.append(
+            decisions
+              |> list.map(fn(item) { decision_request_view(item, answers) }),
+            [
+              html.button(
+                [
+                  attribute.class("btn btn-primary"),
+                  event.on_click(SubmitDecisions),
+                ],
+                [html.text("Submit Decisions")],
+              ),
+            ],
+          ),
+        )
+    },
+  ])
+}
+
+fn recovery_panel(run: RunView) {
+  html.div([], [
+    html.h2([], [html.text("Recovery")]),
+    case run.setup_blocker {
+      Some(blocker) ->
+        html.div([attribute.class("recovery-block")], [
+          html.p([], [
+            html.text(
+              "Blocked during " <> blocker.phase <> " " <> blocker.kind <> ".",
+            ),
+          ]),
+          html.p([attribute.class("muted")], [html.text(blocker.message)]),
+          text_line("Log", blocker.log_path),
+          html.div([attribute.class("button-row")], [
+            html.button(
+              [
+                attribute.class("btn btn-sm"),
+                event.on_click(RecoveryAction("inspect", None)),
+              ],
+              [html.text("Inspect")],
+            ),
+            html.button(
+              [
+                attribute.class("btn btn-primary btn-sm"),
+                event.on_click(RecoveryAction("continue", None)),
+              ],
+              [html.text("Continue")],
+            ),
+            html.button(
+              [
+                attribute.class("btn btn-sm"),
+                event.on_click(RecoveryAction("abandon", None)),
+              ],
+              [html.text("Abandon")],
+            ),
+          ]),
+        ])
+      None ->
+        case run.implementation_blockers {
+          [] ->
+            html.p([attribute.class("muted")], [
+              html.text("No recovery blockers are active."),
+            ])
+          [task, ..] ->
+            html.div([attribute.class("recovery-block")], [
+              html.p([], [
+                html.text(
+                  "Interrupted implementation work is waiting on operator input.",
+                ),
+              ]),
+              html.p([attribute.class("muted")], [
+                html.text(task.title <> " · " <> task.worktree_path),
+              ]),
+              html.div([attribute.class("button-row")], [
+                html.button(
+                  [
+                    attribute.class("btn btn-sm"),
+                    event.on_click(RecoveryAction("inspect", Some(task.id))),
+                  ],
+                  [html.text("Inspect")],
+                ),
+                html.button(
+                  [
+                    attribute.class("btn btn-primary btn-sm"),
+                    event.on_click(RecoveryAction("continue", Some(task.id))),
+                  ],
+                  [html.text("Continue")],
+                ),
+                html.button(
+                  [
+                    attribute.class("btn btn-sm"),
+                    event.on_click(RecoveryAction("complete", Some(task.id))),
+                  ],
+                  [html.text("Complete")],
+                ),
+                html.button(
+                  [
+                    attribute.class("btn btn-sm"),
+                    event.on_click(RecoveryAction("abandon", Some(task.id))),
+                  ],
+                  [html.text("Abandon")],
+                ),
+              ]),
+            ])
+        }
+    },
+  ])
+}
+
+fn repo_state_panel(run: RunView) {
+  html.div([], [
+    html.h2([], [html.text("Repo State")]),
+    case run.repo_state {
+      Some(repo_state) ->
+        html.div([], [
+          text_line("Snapshot", repo_state.snapshot_captured_at),
+          text_line("Drift", repo_state.drift),
+          html.h3([], [html.text("Actionable PRs")]),
+          pr_list(repo_state.actionable_pull_requests),
+          html.h3([], [html.text("Impacted PRs")]),
+          pr_list(repo_state.impacted_pull_requests),
+          html.h3([], [html.text("Replacement Lineage")]),
+          html.ul(
+            [attribute.class("lineage-list")],
+            repo_state.replacement_lineage |> list.map(lineage_item),
+          ),
+        ])
+      None ->
+        html.p([attribute.class("muted")], [
+          html.text("This run was not planned from review context."),
+        ])
+    },
+  ])
+}
+
+fn delivery_panel(run: RunView) {
+  html.div([], [
+    html.h2([], [html.text("Delivery")]),
+    case run.delivery {
+      [] ->
+        html.p([attribute.class("muted")], [html.text("No delivered PRs yet.")])
+      rows ->
+        html.ul(
+          [attribute.class("delivery-list")],
+          rows
+            |> list.map(fn(row) {
+              html.li([], [
+                html.a(
+                  [
+                    attribute.href(row.pr_url),
+                    attribute.target("_blank"),
+                    attribute.rel("noreferrer"),
+                  ],
+                  [html.text(row.task_title <> " · PR #" <> row.pr_number)],
+                ),
+              ])
+            }),
+        )
+    },
+  ])
+}
+
+fn timeline_panel(run: RunView) {
+  html.div([], [
+    html.h2([], [html.text("Timeline")]),
+    html.ul(
+      [attribute.class("timeline")],
+      run.timeline
+        |> list.map(fn(entry) {
+          html.li([], [
+            html.span([attribute.class("event-kind")], [
+              html.text(entry.kind),
+            ]),
+            html.span([attribute.class("event-time")], [
+              html.text(entry.at),
+            ]),
+            html.span([attribute.class("event-message")], [
+              html.text(entry.message),
+            ]),
+          ])
+        }),
+    ),
+  ])
+}
+
+fn markdown_panel(title: String, markdown: String, url: String) {
+  html.div([attribute.class("markdown-panel")], [
+    html.div([attribute.class("panel-head")], [
+      html.h2([], [html.text(title)]),
+      html.a(
+        [
+          attribute.href(url),
+          attribute.target("_blank"),
+          attribute.rel("noreferrer"),
+        ],
+        [html.text("Open artifact")],
+      ),
+    ]),
+    html.pre([attribute.class("markdown")], [html.text(markdown)]),
+  ])
+}
+
+fn notice_view(notice: Option(Notice)) {
+  case notice {
+    Some(n) ->
+      html.div([attribute.class("notice " <> n.kind)], [
+        html.text(n.message),
+      ])
+    None -> html.text("")
+  }
+}
+
+fn decision_request_view(
+  item: PendingDecision,
+  answers: List(#(String, String)),
+) {
+  html.div([attribute.class("decision-block")], [
+    html.h3([], [html.text(item.task_title)]),
+    html.p([], [html.text(item.request.question)]),
+    html.p([attribute.class("muted")], [html.text(item.request.rationale)]),
+    html.textarea(
+      [
+        attribute.placeholder("Answer"),
+        attribute.value(answer_for(answers, item.request.key)),
+        event.on_input(fn(value) {
+          UpdateDecisionAnswer(item.request.key, value)
+        }),
+      ],
+      answer_for(answers, item.request.key),
+    ),
+    html.ul([], item.request.options |> list.map(decision_option_view)),
+  ])
+}
+
+fn decision_option_view(opt: DecisionOption) {
+  html.li([], [html.text(opt.label <> ": " <> opt.description)])
+}
+
+fn pr_list(rows: List(PullRequestView)) {
+  case rows {
+    [] -> html.p([attribute.class("muted")], [html.text("None.")])
+    _ ->
+      html.ul(
+        [attribute.class("pr-list")],
+        rows
+          |> list.map(fn(pr) {
+            html.li([], [
+              html.a(
+                [
+                  attribute.href(pr.url),
+                  attribute.target("_blank"),
+                  attribute.rel("noreferrer"),
+                ],
+                [html.text("#" <> int_to_string(pr.number) <> " " <> pr.title)],
+              ),
+            ])
+          }),
+      )
+  }
+}
+
+fn lineage_item(item: LineageView) {
+  html.li([], [
+    html.text(
+      item.task_id
+      <> " supersedes "
+      <> render_pr_numbers(item.superseded_pr_numbers)
+      <> case item.replacement_pr_number {
+        Some(pr_number) -> " -> #" <> pr_number
+        None -> ""
+      },
+    ),
+  ])
+}
+
+fn text_field(
+  label: String,
+  placeholder: String,
+  value: String,
+  to_msg: fn(String) -> Msg,
+) {
+  html.label([attribute.class("field")], [
+    html.span([], [html.text(label)]),
+    html.input([
+      attribute.type_("text"),
+      attribute.placeholder(placeholder),
+      attribute.value(value),
+      event.on_input(to_msg),
+    ]),
+  ])
+}
+
+fn select_field(
+  label: String,
+  options: List(String),
+  selected: String,
+  to_msg: fn(String) -> Msg,
+) {
+  html.label([attribute.class("field")], [
+    html.span([], [html.text(label)]),
+    html.select(
+      [event.on_change(to_msg)],
+      options
+        |> list.map(fn(opt) {
+          html.option(
+            [attribute.value(opt), attribute.selected(opt == selected)],
+            opt,
+          )
+        }),
+    ),
+  ])
+}
+
+fn select_models_field(models: List(ProviderModel), selected: String) {
+  html.label([attribute.class("field")], [
+    html.span([], [html.text("Model")]),
+    html.select([event.on_change(UpdateInitModel)], case models {
+      [] -> [html.option([attribute.value("")], "Discovering models...")]
+      _ ->
+        models
+        |> list.map(fn(m) {
+          html.option(
+            [
+              attribute.value(m.id),
+              attribute.selected(m.id == selected),
+            ],
+            m.label,
+          )
+        })
+    }),
+  ])
+}
+
+fn checkbox_field(label: String, value: Bool) {
+  html.label([attribute.class("checkbox")], [
+    html.input([
+      attribute.type_("checkbox"),
+      attribute.checked(value),
+      event.on_check(ToggleGenerateSetup),
+    ]),
+    html.span([], [html.text(label)]),
+  ])
+}
+
+fn meta_card(label: String, value: String) {
+  html.div([attribute.class("meta-card")], [
+    html.span([attribute.class("meta-label")], [html.text(label)]),
+    html.span([attribute.class("meta-value")], [html.text(value)]),
+  ])
+}
+
+fn detail_line(label: String, url: Option(String), _fallback: String) {
+  case url {
+    Some(link) ->
+      case string.trim(link) {
+        "" -> html.text("")
+        trimmed ->
+          html.div([attribute.class("detail-line")], [
+            html.strong([], [html.text(label <> ": ")]),
+            html.a(
+              [
+                attribute.href(trimmed),
+                attribute.target("_blank"),
+                attribute.rel("noreferrer"),
+              ],
+              [html.text(trimmed)],
+            ),
+          ])
+      }
+    None -> html.text("")
+  }
+}
+
+fn text_line(label: String, value: String) {
+  html.div([attribute.class("detail-line")], [
+    html.strong([], [html.text(label <> ": ")]),
+    html.span([], [html.text(non_empty(value, "—"))]),
+  ])
+}
+
+fn maybe_link_line(label: String, url: Option(String), fallback: String) {
+  case url {
+    Some(link) ->
+      html.div([attribute.class("detail-line")], [
+        html.strong([], [html.text(label <> ": ")]),
+        html.a(
+          [
+            attribute.href(link),
+            attribute.target("_blank"),
+            attribute.rel("noreferrer"),
+          ],
+          [html.text(non_empty(fallback, link))],
+        ),
+      ])
+    None -> text_line(label, fallback)
+  }
+}
+
+fn selected_run(workspace: Option(Workspace)) -> Option(RunView) {
+  case workspace {
+    Some(workspace) -> workspace.run
+    None -> None
+  }
+}
+
+fn active_command(workspace: Option(Workspace)) -> Option(CommandState) {
+  case workspace {
+    Some(workspace) -> workspace.command_state
+    None -> None
+  }
+}
+
+fn selected_task(
+  tasks: List(TaskView),
+  selected_task_id: Option(String),
+) -> Option(TaskView) {
+  case selected_task_id {
+    Some(task_id) -> find_task(tasks, task_id)
+    None ->
+      case tasks {
+        [task, ..] -> Some(task)
+        [] -> None
+      }
+  }
+}
+
+fn find_task(tasks: List(TaskView), task_id: String) -> Option(TaskView) {
+  case tasks {
+    [] -> None
+    [task, ..rest] ->
+      case task.id == task_id {
+        True -> Some(task)
+        False -> find_task(rest, task_id)
+      }
+  }
+}
+
+fn resolve_selected_task(
+  current: Option(String),
+  workspace: Workspace,
+) -> Option(String) {
+  case workspace.run {
+    Some(run) ->
+      case current {
+        Some(task_id) ->
+          case find_task(run.tasks, task_id) {
+            Some(_) -> Some(task_id)
+            None -> first_task_id(run.tasks)
+          }
+        None -> first_task_id(run.tasks)
+      }
+    None -> None
+  }
+}
+
+fn first_task_id(tasks: List(TaskView)) -> Option(String) {
+  case tasks {
+    [task, ..] -> Some(task.id)
+    [] -> None
+  }
+}
+
+fn fetch_workspace_effect(target_run: String) -> effect.Effect(Msg) {
+  effect.from(fn(dispatch) {
+    fetch_workspace_raw(
+      target_run,
+      fn(payload) { dispatch(WorkspaceLoaded(payload)) },
+      fn(message) { dispatch(WorkspaceLoadFailed(message)) },
+    )
+  })
+}
+
+fn fetch_models_effect(provider: String) -> effect.Effect(Msg) {
+  effect.from(fn(dispatch) {
+    fetch_models_raw(
+      provider,
+      fn(payload) { dispatch(ModelsLoaded(payload)) },
+      fn(message) { dispatch(ModelsLoadFailed(message)) },
+    )
+  })
+}
+
+fn open_stream_effect(target_run: String) -> effect.Effect(Msg) {
+  effect.from(fn(dispatch) {
+    open_event_stream_raw(
+      target_run,
+      fn(_) { dispatch(StreamOpened) },
+      fn(payload) { dispatch(StreamMessage(payload)) },
+      fn(_) { dispatch(StreamErrored) },
+    )
+  })
+}
+
+fn post_effect(path: String, payload: String) -> effect.Effect(Msg) {
+  effect.from(fn(dispatch) {
+    post_json_raw(
+      path,
+      payload,
+      fn(response) { dispatch(ActionSucceeded(response)) },
+      fn(message) { dispatch(ActionFailed(message)) },
+    )
+  })
+}
+
+fn selected_run_target(selected_run_id: Option(String)) -> String {
+  case selected_run_id {
+    Some(run_id) -> run_id
+    None -> "latest"
+  }
+}
+
+fn init_payload(form: InitForm) -> String {
+  json.object([
+    #("provider", json.string(form.provider)),
+    #("model", json.string(form.model)),
+    #("reasoning", nullable_string(form.reasoning)),
+    #("generate_setup", json.bool(form.generate_setup)),
+  ])
+  |> json.to_string
+}
+
+fn plan_payload(form: PlanForm) -> String {
+  json.object([
+    #("notes", nullable_string(form.notes)),
+    #("doc_path", nullable_string(form.doc_path)),
+  ])
+  |> json.to_string
+}
+
+fn decisions_payload(
+  answers: List(#(String, String)),
+  decisions: List(PendingDecision),
+) -> String {
+  json.object([
+    #(
+      "answers",
+      json.array(decisions, fn(item) {
+        json.object([
+          #("key", json.string(item.request.key)),
+          #("question", json.string(item.request.question)),
+          #("answer", json.string(answer_for(answers, item.request.key))),
+        ])
+      }),
+    ),
+  ])
+  |> json.to_string
+}
+
+fn recovery_payload(task_id: Option(String)) -> String {
+  json.object([
+    #("task_id", json.nullable(from: task_id, of: json.string)),
+  ])
+  |> json.to_string
+}
+
+fn nullable_string(value: String) -> json.Json {
+  case string.trim(value) {
+    "" -> json.null()
+    trimmed -> json.string(trimmed)
+  }
+}
+
+fn put_answer(
+  answers: List(#(String, String)),
+  key: String,
+  value: String,
+) -> List(#(String, String)) {
+  case answers {
+    [] -> [#(key, value)]
+    [entry, ..rest] ->
+      case entry.0 == key {
+        True -> [#(key, value), ..rest]
+        False -> [entry, ..put_answer(rest, key, value)]
+      }
+  }
+}
+
+fn answer_for(answers: List(#(String, String)), key: String) -> String {
+  case answers {
+    [] -> ""
+    [entry, ..rest] ->
+      case entry.0 == key {
+        True -> entry.1
+        False -> answer_for(rest, key)
+      }
+  }
+}
+
+fn decode_workspace(payload: String) -> Result(Workspace, String) {
+  json.parse(payload, workspace_decoder())
+  |> result.map_error(fn(_) { "Unable to decode workspace payload." })
+}
+
+fn decode_models(payload: String) -> Result(List(ProviderModel), String) {
+  json.parse(payload, {
+    use _provider <- decode.field("provider", decode.string)
+    use models <- decode.field("models", decode.list(provider_model_decoder()))
+    decode.success(models)
+  })
+  |> result.map_error(fn(_) { "Unable to decode model list." })
+}
+
+fn decode_action_response(payload: String) -> Result(ActionResponse, String) {
+  json.parse(payload, action_response_decoder())
+  |> result.map_error(fn(_) { "Unable to decode action response." })
+}
+
+fn workspace_decoder() -> decode.Decoder(Workspace) {
+  use repo_root <- decode.field("repo_root", decode.string)
+  use initialized <- decode.field("initialized", decode.bool)
+  use default_profile <- decode.field("default_profile", decode.string)
+  use providers <- decode.field("providers", decode.list(decode.string))
+  use selected_run_id <- decode.optional_field(
+    "selected_run_id",
+    None,
+    decode.optional(decode.string),
+  )
+  use runs <- decode.field("runs", decode.list(run_summary_decoder()))
+  use command_state <- decode.optional_field(
+    "command_state",
+    None,
+    decode.optional(command_state_decoder()),
+  )
+  use run <- decode.optional_field("run", None, decode.optional(run_decoder()))
+  decode.success(Workspace(
+    repo_root: repo_root,
+    initialized: initialized,
+    default_profile: default_profile,
+    providers: providers,
+    runs: runs,
+    selected_run_id: selected_run_id,
+    command_state: command_state,
+    run: run,
+  ))
+}
+
+fn run_summary_decoder() -> decode.Decoder(RunSummary) {
+  use run_id <- decode.field("run_id", decode.string)
+  use status <- decode.field("status", decode.string)
+  use created_at <- decode.field("created_at", decode.string)
+  use updated_at <- decode.field("updated_at", decode.string)
+  use task_count <- decode.field("task_count", decode.int)
+  decode.success(RunSummary(
+    run_id: run_id,
+    status: status,
+    created_at: created_at,
+    updated_at: updated_at,
+    task_count: task_count,
+  ))
+}
+
+fn command_state_decoder() -> decode.Decoder(CommandState) {
+  use name <- decode.field("name", decode.string)
+  use run_id <- decode.optional_field(
+    "run_id",
+    None,
+    decode.optional(decode.string),
+  )
+  use started_at <- decode.field("started_at", decode.string)
+  use summary <- decode.field("summary", decode.string)
+  decode.success(CommandState(
+    name: name,
+    run_id: run_id,
+    started_at: started_at,
+    summary: summary,
+  ))
+}
+
+fn run_decoder() -> decode.Decoder(RunView) {
+  use run_id <- decode.field("run_id", decode.string)
+  use status <- decode.field("status", decode.string)
+  use created_at <- decode.field("created_at", decode.string)
+  use updated_at <- decode.field("updated_at", decode.string)
+  use next_action <- decode.field("next_action", decode.string)
+  use planning_provenance <- decode.field(
+    "planning_provenance",
+    planning_projection_decoder(),
+  )
+  use notes_source <- decode.optional_field(
+    "notes_source",
+    None,
+    decode.optional(notes_source_decoder()),
+  )
+  use confidence <- decode.field("confidence", confidence_decoder())
+  use dag <- decode.field("dag", dag_decoder())
+  use tasks <- decode.field("tasks", decode.list(task_decoder()))
+  use decisions <- decode.field(
+    "decisions",
+    decode.list(pending_decision_decoder()),
+  )
+  use repo_state <- decode.optional_field(
+    "repo_state",
+    None,
+    decode.optional(repo_state_decoder()),
+  )
+  use timeline <- decode.field(
+    "timeline",
+    decode.list(timeline_entry_decoder()),
+  )
+  use report_markdown <- decode.field("report_markdown", decode.string)
+  use provenance_markdown <- decode.field("provenance_markdown", decode.string)
+  use delivery <- decode.field("delivery", decode.list(delivery_decoder()))
+  use recovery <- decode.field("recovery", recovery_decoder())
+  use artifacts <- decode.field("artifacts", artifacts_decoder())
+  decode.success(RunView(
+    run_id: run_id,
+    status: status,
+    created_at: created_at,
+    updated_at: updated_at,
+    next_action: next_action,
+    planning_label: planning_provenance.0,
+    uses_reviews: planning_provenance.1,
+    notes_label: case notes_source {
+      Some(label) -> label
+      None -> "—"
+    },
+    confidence_level: confidence.0,
+    confidence_reasons: confidence.1,
+    tasks: tasks,
+    dag_nodes: dag.0,
+    dag_edges: dag.1,
+    decisions: decisions,
+    repo_state: repo_state,
+    timeline: timeline,
+    report_markdown: report_markdown,
+    provenance_markdown: provenance_markdown,
+    delivery: delivery,
+    setup_blocker: recovery.0,
+    implementation_blockers: recovery.1,
+    report_url: artifacts.0,
+    provenance_url: artifacts.1,
+  ))
+}
+
+fn planning_projection_decoder() -> decode.Decoder(#(String, Bool)) {
+  use label <- decode.field("label", decode.string)
+  use uses_reviews <- decode.field("uses_reviews", decode.bool)
+  decode.success(#(label, uses_reviews))
+}
+
+fn notes_source_decoder() -> decode.Decoder(String) {
+  use label <- decode.field("label", decode.string)
+  decode.success(label)
+}
+
+fn confidence_decoder() -> decode.Decoder(#(String, List(String))) {
+  use level <- decode.field("level", decode.string)
+  use reasons <- decode.field("reasons", decode.list(decode.string))
+  decode.success(#(level, reasons))
+}
+
+fn dag_decoder() -> decode.Decoder(#(List(DagNode), List(DagEdge))) {
+  use nodes <- decode.field("nodes", decode.list(dag_node_decoder()))
+  use edges <- decode.field("edges", decode.list(dag_edge_decoder()))
+  decode.success(#(nodes, edges))
+}
+
+fn dag_node_decoder() -> decode.Decoder(DagNode) {
+  use id <- decode.field("id", decode.string)
+  use title <- decode.field("title", decode.string)
+  use state <- decode.field("state", decode.string)
+  use kind <- decode.field("kind", decode.string)
+  use branch_name <- decode.field("branch_name", decode.string)
+  use pr_number <- decode.field("pr_number", decode.string)
+  use pr_url <- decode.optional_field(
+    "pr_url",
+    None,
+    decode.optional(decode.string),
+  )
+  decode.success(DagNode(
+    id: id,
+    title: title,
+    state: state,
+    kind: kind,
+    branch_name: branch_name,
+    pr_number: pr_number,
+    pr_url: pr_url,
+  ))
+}
+
+fn dag_edge_decoder() -> decode.Decoder(DagEdge) {
+  use from <- decode.field("from", decode.string)
+  use to <- decode.field("to", decode.string)
+  decode.success(DagEdge(from: from, to: to))
+}
+
+fn task_decoder() -> decode.Decoder(TaskView) {
+  use id <- decode.field("id", decode.string)
+  use title <- decode.field("title", decode.string)
+  use description <- decode.field("description", decode.string)
+  use summary <- decode.field("summary", decode.string)
+  use state <- decode.field("state", decode.string)
+  use kind <- decode.field("kind", decode.string)
+  use execution_mode <- decode.field("execution_mode", decode.string)
+  use dependencies <- decode.field("dependencies", decode.list(decode.string))
+  use acceptance <- decode.field("acceptance", decode.list(decode.string))
+  use demo_plan <- decode.field("demo_plan", decode.list(decode.string))
+  use branch_name <- decode.field("branch_name", decode.string)
+  use pr_number <- decode.field("pr_number", decode.string)
+  use pr_url <- decode.optional_field(
+    "pr_url",
+    None,
+    decode.optional(decode.string),
+  )
+  use superseded_pr_numbers <- decode.field(
+    "superseded_pr_numbers",
+    decode.list(decode.int),
+  )
+  use worktree_path <- decode.field("worktree_path", decode.string)
+  use artifacts <- decode.field("artifacts", task_artifacts_decoder())
+  decode.success(TaskView(
+    id: id,
+    title: title,
+    description: description,
+    summary: summary,
+    state: state,
+    kind: kind,
+    execution_mode: execution_mode,
+    dependencies: dependencies,
+    acceptance: acceptance,
+    demo_plan: demo_plan,
+    branch_name: branch_name,
+    pr_number: pr_number,
+    pr_url: pr_url,
+    superseded_pr_numbers: superseded_pr_numbers,
+    worktree_path: worktree_path,
+    task_log_url: artifacts.0,
+    verify_log_url: artifacts.1,
+  ))
+}
+
+fn task_artifacts_decoder() -> decode.Decoder(#(String, String)) {
+  use task_log_url <- decode.field("task_log_url", decode.string)
+  use verify_log_url <- decode.field("verify_log_url", decode.string)
+  decode.success(#(task_log_url, verify_log_url))
+}
+
+fn pending_decision_decoder() -> decode.Decoder(PendingDecision) {
+  use task_id <- decode.field("task_id", decode.string)
+  use task_title <- decode.field("task_title", decode.string)
+  use request <- decode.field("request", decision_request_decoder())
+  decode.success(PendingDecision(
+    task_id: task_id,
+    task_title: task_title,
+    request: request,
+  ))
+}
+
+fn decision_request_decoder() -> decode.Decoder(DecisionRequest) {
+  use key <- decode.field("key", decode.string)
+  use question <- decode.field("question", decode.string)
+  use rationale <- decode.field("rationale", decode.string)
+  use options <- decode.field("options", decode.list(decision_option_decoder()))
+  use recommended_option <- decode.optional_field(
+    "recommended_option",
+    None,
+    decode.optional(decode.string),
+  )
+  use allow_freeform <- decode.field("allow_freeform", decode.bool)
+  decode.success(DecisionRequest(
+    key: key,
+    question: question,
+    rationale: rationale,
+    options: options,
+    recommended_option: recommended_option,
+    allow_freeform: allow_freeform,
+  ))
+}
+
+fn decision_option_decoder() -> decode.Decoder(DecisionOption) {
+  use label <- decode.field("label", decode.string)
+  use description <- decode.field("description", decode.string)
+  decode.success(DecisionOption(label: label, description: description))
+}
+
+fn repo_state_decoder() -> decode.Decoder(RepoStateView) {
+  use repo_state <- decode.field("repo_state", repo_state_summary_decoder())
+  use replacement_lineage <- decode.field(
+    "replacement_lineage",
+    decode.list(lineage_decoder()),
+  )
+  decode.success(RepoStateView(
+    snapshot_captured_at: repo_state.0,
+    drift: repo_state.1,
+    actionable_pull_requests: repo_state.2,
+    impacted_pull_requests: repo_state.3,
+    replacement_lineage: replacement_lineage,
+  ))
+}
+
+fn repo_state_summary_decoder() -> decode.Decoder(
+  #(String, String, List(PullRequestView), List(PullRequestView)),
+) {
+  use snapshot_captured_at <- decode.field(
+    "snapshot_captured_at",
+    decode.string,
+  )
+  use drift <- decode.optional_field("drift", "unknown", decode.string)
+  use actionable_pull_requests <- decode.field(
+    "actionable_pull_requests",
+    decode.list(pull_request_decoder()),
+  )
+  use impacted_pull_requests <- decode.field(
+    "impacted_pull_requests",
+    decode.list(pull_request_decoder()),
+  )
+  decode.success(#(
+    snapshot_captured_at,
+    drift,
+    actionable_pull_requests,
+    impacted_pull_requests,
+  ))
+}
+
+fn pull_request_decoder() -> decode.Decoder(PullRequestView) {
+  use number <- decode.field("number", decode.int)
+  use title <- decode.field("title", decode.string)
+  use branch_name <- decode.field("branch_name", decode.string)
+  use url <- decode.field("url", decode.string)
+  decode.success(PullRequestView(
+    number: number,
+    title: title,
+    branch_name: branch_name,
+    url: url,
+  ))
+}
+
+fn lineage_decoder() -> decode.Decoder(LineageView) {
+  use task_id <- decode.field("task_id", decode.string)
+  use superseded_pr_numbers <- decode.field(
+    "superseded_pr_numbers",
+    decode.list(decode.int),
+  )
+  use replacement_pr_number <- decode.optional_field(
+    "replacement_pr_number",
+    None,
+    decode.optional(decode.string),
+  )
+  decode.success(LineageView(
+    task_id: task_id,
+    superseded_pr_numbers: superseded_pr_numbers,
+    replacement_pr_number: replacement_pr_number,
+  ))
+}
+
+fn timeline_entry_decoder() -> decode.Decoder(TimelineEntry) {
+  use kind <- decode.field("kind", decode.string)
+  use at <- decode.field("at", decode.string)
+  use message <- decode.field("message", decode.string)
+  use task_id <- decode.optional_field(
+    "task_id",
+    None,
+    decode.optional(decode.string),
+  )
+  decode.success(TimelineEntry(
+    kind: kind,
+    at: at,
+    message: message,
+    task_id: task_id,
+  ))
+}
+
+fn delivery_decoder() -> decode.Decoder(DeliveryView) {
+  use task_id <- decode.field("task_id", decode.string)
+  use task_title <- decode.field("task_title", decode.string)
+  use pr_number <- decode.field("pr_number", decode.string)
+  use pr_url <- decode.field("pr_url", decode.string)
+  decode.success(DeliveryView(
+    task_id: task_id,
+    task_title: task_title,
+    pr_number: pr_number,
+    pr_url: pr_url,
+  ))
+}
+
+fn recovery_decoder() -> decode.Decoder(
+  #(Option(RecoveryBlocker), List(TaskView)),
+) {
+  use setup_blocker <- decode.optional_field(
+    "setup_blocker",
+    None,
+    decode.optional(recovery_blocker_decoder()),
+  )
+  use implementation_blockers <- decode.field(
+    "implementation_blockers",
+    decode.list(task_decoder()),
+  )
+  decode.success(#(setup_blocker, implementation_blockers))
+}
+
+fn recovery_blocker_decoder() -> decode.Decoder(RecoveryBlocker) {
+  use kind <- decode.field("kind", decode.string)
+  use phase <- decode.field("phase", decode.string)
+  use task_id <- decode.optional_field(
+    "task_id",
+    None,
+    decode.optional(decode.string),
+  )
+  use message <- decode.field("message", decode.string)
+  use log_path <- decode.field("log_path", decode.string)
+  use disposition <- decode.field("disposition", decode.string)
+  decode.success(RecoveryBlocker(
+    kind: kind,
+    phase: phase,
+    task_id: task_id,
+    message: message,
+    log_path: log_path,
+    disposition: disposition,
+  ))
+}
+
+fn artifacts_decoder() -> decode.Decoder(#(String, String)) {
+  use report_url <- decode.field("report_url", decode.string)
+  use provenance_url <- decode.field("provenance_url", decode.string)
+  decode.success(#(report_url, provenance_url))
+}
+
+fn provider_model_decoder() -> decode.Decoder(ProviderModel) {
+  use id <- decode.field("id", decode.string)
+  use label <- decode.field("label", decode.string)
+  use is_default <- decode.field("is_default", decode.bool)
+  decode.success(ProviderModel(id: id, label: label, is_default: is_default))
+}
+
+fn action_response_decoder() -> decode.Decoder(ActionResponse) {
+  use summary <- decode.field("summary", decode.string)
+  use next_action <- decode.field("next_action", decode.string)
+  use run_id <- decode.optional_field(
+    "run_id",
+    None,
+    decode.optional(decode.string),
+  )
+  decode.success(ActionResponse(
+    summary: summary,
+    next_action: next_action,
+    run_id: run_id,
+  ))
+}
+
+fn node_layer(task_id: String, tasks: List(TaskView)) -> String {
+  int_to_string(1 + task_depth(task_id, tasks))
+}
+
+fn task_depth(task_id: String, tasks: List(TaskView)) -> Int {
+  case find_task(tasks, task_id) {
+    Some(task) ->
+      case task.dependencies {
+        [] -> 0
+        dependencies -> max_depth(dependencies, tasks, 0)
+      }
+    None -> 0
+  }
+}
+
+fn max_depth(
+  dependencies: List(String),
+  tasks: List(TaskView),
+  current: Int,
+) -> Int {
+  case dependencies {
+    [] -> current
+    [dependency, ..rest] -> {
+      let depth = 1 + task_depth(dependency, tasks)
+      max_depth(rest, tasks, max_int(current, depth))
+    }
+  }
+}
+
+fn max_int(left: Int, right: Int) -> Int {
+  case left > right {
+    True -> left
+    False -> right
+  }
+}
+
+fn non_empty(value: String, fallback: String) -> String {
+  case string.trim(value) {
+    "" -> fallback
+    trimmed -> trimmed
+  }
+}
+
+fn render_pr_numbers(numbers: List(Int)) -> String {
+  case numbers {
+    [] -> "—"
+    _ ->
+      numbers
+      |> list.map(fn(number) { "#" <> int_to_string(number) })
+      |> string.join(with: ", ")
+  }
+}
+
+fn default_model_id(models: List(ProviderModel), existing: String) -> String {
+  case string.trim(existing) {
+    "" ->
+      case list.find(models, fn(model) { model.is_default }) {
+        Ok(model) -> model.id
+        Error(_) ->
+          case models {
+            [model, ..] -> model.id
+            [] -> ""
+          }
+      }
+    value -> value
+  }
+}
+
+fn int_to_string(value: Int) -> String {
+  int.to_string(value)
+}
+
+fn suggest_tab(current: String, workspace: Workspace) -> String {
+  case current == "graph", workspace.run {
+    True, Some(run) ->
+      case run.decisions, run.setup_blocker, run.implementation_blockers {
+        [_, ..], _, _ -> "decisions"
+        _, Some(_), _ -> "recovery"
+        _, _, [_, ..] -> "recovery"
+        _, _, _ -> current
+      }
+    _, _ -> current
+  }
+}
diff --git a/dash_web/static/dash.css b/dash_web/static/dash.css
new file mode 100644
index 0000000..76dca8a
--- /dev/null
+++ b/dash_web/static/dash.css
@@ -0,0 +1,914 @@
+/* ============================================================
+   Night Shift Dashboard — "Night Reader" control surface
+   Dark, editorial, warm gold. Adapted from docs/assets/site.css
+   for an interactive operator dashboard.
+   ============================================================ */
+
+:root {
+  color-scheme: dark;
+
+  --bg:            #0c0c0f;
+  --bg-raised:     #141419;
+  --bg-hover:      #1c1c23;
+  --bg-inset:      #09090c;
+  --ink:           #e2ddd5;
+  --ink-secondary: #9b958c;
+  --ink-tertiary:  #635e57;
+  --line:          rgba(255, 255, 255, 0.07);
+  --accent:        #c9a55a;
+  --accent-hover:  #ddb865;
+  --accent-soft:   rgba(201, 165, 90, 0.10);
+
+  --ok:            #44aa99;
+  --ok-soft:       rgba(68, 170, 153, 0.12);
+  --warn:          #cc9900;
+  --warn-soft:     rgba(204, 153, 0, 0.12);
+  --danger:        #cc4444;
+  --danger-soft:   rgba(204, 68, 68, 0.12);
+  --info:          #6688bb;
+  --info-soft:     rgba(102, 136, 187, 0.12);
+
+  --radius:        10px;
+  --radius-sm:     6px;
+  --sans:          "Outfit", system-ui, sans-serif;
+  --serif:         "Newsreader", "Georgia", serif;
+  --mono:          "JetBrains Mono", ui-monospace, "Cascadia Code", monospace;
+}
+
+*, *::before, *::after { box-sizing: border-box; }
+
+::selection {
+  background: rgba(201, 165, 90, 0.30);
+  color: var(--ink);
+}
+
+body {
+  margin: 0;
+  background: var(--bg);
+  color: var(--ink);
+  font-family: var(--sans);
+  font-weight: 400;
+  font-size: 15px;
+  line-height: 1.7;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+a { color: var(--accent); text-decoration: none; transition: color 0.15s ease; }
+a:hover { color: var(--accent-hover); }
+
+button, input, select, textarea { font: inherit; }
+button { cursor: pointer; }
+
+#app { min-height: 100vh; }
+
+/* --- Accent bar --------------------------------------------------- */
+
+.accent-bar {
+  height: 2px;
+  background: linear-gradient(90deg, var(--accent) 0%, transparent 55%);
+}
+
+/* --- Shell -------------------------------------------------------- */
+
+.shell {
+  max-width: 1120px;
+  margin: 0 auto;
+  padding: 0 1.5rem 2rem;
+}
+
+/* --- Topbar ------------------------------------------------------- */
+
+.topbar {
+  display: flex;
+  align-items: center;
+  gap: 1.5rem;
+  padding: 0.75rem 0;
+  border-bottom: 1px solid var(--line);
+  margin-bottom: 1.5rem;
+}
+
+.topbar-brand {
+  margin-right: auto;
+  display: flex;
+  align-items: baseline;
+  gap: 0.6rem;
+}
+
+.topbar-brand h1 {
+  margin: 0;
+  font-family: var(--serif);
+  font-size: 1.15rem;
+  font-weight: 500;
+  letter-spacing: -0.01em;
+  line-height: 1;
+}
+
+.topbar-brand .repo-root {
+  font-family: var(--mono);
+  font-size: 0.75rem;
+  color: var(--ink-tertiary);
+}
+
+.topbar-meta {
+  display: flex;
+  align-items: center;
+  gap: 1.25rem;
+}
+
+/* --- Meta cards (topbar + run bar) -------------------------------- */
+
+.meta-card {
+  display: flex;
+  flex-direction: column;
+  gap: 0.1rem;
+}
+
+.meta-card .meta-label {
+  font-size: 0.62rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.14em;
+  color: var(--ink-tertiary);
+  line-height: 1;
+}
+
+.meta-card .meta-value {
+  font-family: var(--mono);
+  font-size: 0.78rem;
+  font-weight: 500;
+  color: var(--ink);
+  line-height: 1.3;
+}
+
+/* --- Connection indicator ----------------------------------------- */
+
+.connection-dot {
+  display: inline-block;
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  margin-right: 0.35rem;
+  vertical-align: middle;
+}
+
+.connection-dot.connected    { background: var(--ok); box-shadow: 0 0 4px var(--ok); }
+.connection-dot.connecting   { background: var(--warn); }
+.connection-dot.disconnected { background: var(--danger); }
+
+/* --- Body layout -------------------------------------------------- */
+
+.body {
+  display: grid;
+  grid-template-columns: 220px minmax(0, 1fr);
+  gap: 1.5rem;
+  align-items: start;
+}
+
+/* --- Sidebar ------------------------------------------------------ */
+
+.sidebar {
+  position: sticky;
+  top: 1rem;
+  display: flex;
+  flex-direction: column;
+  gap: 1.25rem;
+  max-height: calc(100vh - 2rem);
+  overflow-y: auto;
+}
+
+.sidebar-section {
+  background: var(--bg-raised);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  padding: 1rem;
+}
+
+.nav-title {
+  margin: 0 0 0.5rem;
+  padding: 0;
+  color: var(--ink-tertiary);
+  font-size: 0.62rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.14em;
+}
+
+/* --- Run list ----------------------------------------------------- */
+
+.run-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+}
+
+.run-link {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  width: 100%;
+  padding: 0.4rem 0.6rem;
+  border: none;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--ink-secondary);
+  text-align: left;
+  font-size: 0.84rem;
+  transition: color 0.15s ease, background 0.15s ease;
+}
+
+.run-link:hover {
+  color: var(--ink);
+  background: var(--bg-hover);
+}
+
+.run-link.active {
+  color: var(--accent);
+  background: var(--accent-soft);
+  font-weight: 500;
+}
+
+.run-link .status-dot {
+  flex-shrink: 0;
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+}
+
+.run-link .run-info {
+  min-width: 0;
+  overflow: hidden;
+}
+
+.run-link .run-id {
+  display: block;
+  font-family: var(--mono);
+  font-size: 0.76rem;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.run-link .run-meta {
+  display: block;
+  font-size: 0.7rem;
+  color: var(--ink-tertiary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+/* --- Status colors ------------------------------------------------ */
+
+.status-pending    { background: var(--info); }
+.status-active     { background: var(--ok); }
+.status-completed  { background: var(--ok); }
+.status-blocked    { background: var(--warn); }
+.status-failed     { background: var(--danger); }
+.status-queued     { background: var(--ink-tertiary); }
+.status-ready      { background: var(--info); }
+.status-running    { background: var(--ok); }
+.status-manual_attention { background: var(--warn); }
+
+/* --- Sidebar forms ------------------------------------------------ */
+
+.sidebar-form {
+  display: flex;
+  flex-direction: column;
+  gap: 0.6rem;
+}
+
+.sidebar-form .field {
+  display: flex;
+  flex-direction: column;
+  gap: 0.2rem;
+}
+
+.sidebar-form .field > span {
+  font-size: 0.72rem;
+  font-weight: 500;
+  color: var(--ink-secondary);
+}
+
+.sidebar-form input[type="text"],
+.sidebar-form select,
+.sidebar-form textarea {
+  width: 100%;
+  padding: 0.4rem 0.55rem;
+  background: var(--bg-hover);
+  border: 1px solid var(--line);
+  border-radius: var(--radius-sm);
+  color: var(--ink);
+  font-size: 0.82rem;
+  transition: border-color 0.15s ease;
+}
+
+.sidebar-form input:focus,
+.sidebar-form select:focus,
+.sidebar-form textarea:focus {
+  outline: none;
+  border-color: var(--accent);
+  box-shadow: 0 0 0 2px var(--accent-soft);
+}
+
+.sidebar-form textarea {
+  min-height: 5rem;
+  resize: vertical;
+  font-family: var(--sans);
+  line-height: 1.5;
+}
+
+.sidebar-form .checkbox {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  font-size: 0.82rem;
+  color: var(--ink-secondary);
+  cursor: pointer;
+}
+
+.sidebar-form .checkbox input { accent-color: var(--accent); }
+
+/* --- Buttons ------------------------------------------------------ */
+
+.btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.35rem;
+  padding: 0.4rem 0.85rem;
+  border: 1px solid var(--line);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--ink);
+  font-size: 0.82rem;
+  font-weight: 500;
+  transition: background 0.15s ease, border-color 0.15s ease, color 0.15s ease;
+}
+
+.btn:hover {
+  background: var(--bg-hover);
+  border-color: rgba(255, 255, 255, 0.12);
+}
+
+.btn-primary {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: #0c0c0f;
+  font-weight: 600;
+}
+
+.btn-primary:hover {
+  background: var(--accent-hover);
+  border-color: var(--accent-hover);
+  color: #0c0c0f;
+}
+
+.btn-sm {
+  padding: 0.3rem 0.65rem;
+  font-size: 0.76rem;
+}
+
+.button-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.4rem;
+}
+
+/* --- Main area ---------------------------------------------------- */
+
+.main-area {
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+/* --- Notice ------------------------------------------------------- */
+
+.notice {
+  padding: 0.6rem 1rem;
+  border-radius: var(--radius-sm);
+  font-size: 0.85rem;
+  font-weight: 500;
+  line-height: 1.4;
+}
+
+.notice.success {
+  background: var(--ok-soft);
+  border: 1px solid rgba(68, 170, 153, 0.25);
+  color: #7ccabc;
+}
+
+.notice.error {
+  background: var(--danger-soft);
+  border: 1px solid rgba(204, 68, 68, 0.25);
+  color: #e08888;
+}
+
+/* --- Run bar ------------------------------------------------------ */
+
+.run-bar {
+  display: flex;
+  align-items: center;
+  gap: 1.25rem;
+  padding: 0.85rem 1.25rem;
+  background: var(--bg-raised);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+}
+
+.run-bar-info {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  flex: 1;
+  min-width: 0;
+}
+
+.run-bar .run-id-label {
+  font-family: var(--mono);
+  font-size: 0.85rem;
+  font-weight: 500;
+  color: var(--ink);
+}
+
+.run-bar .status-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  padding: 0.15rem 0.55rem;
+  border-radius: 999px;
+  font-size: 0.7rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+}
+
+.status-badge.pending   { background: var(--info-soft); color: var(--info); }
+.status-badge.active    { background: var(--ok-soft); color: var(--ok); }
+.status-badge.completed { background: var(--ok-soft); color: var(--ok); }
+.status-badge.blocked   { background: var(--warn-soft); color: var(--warn); }
+.status-badge.failed    { background: var(--danger-soft); color: var(--danger); }
+
+.run-bar .next-action {
+  font-size: 0.82rem;
+  color: var(--ink-secondary);
+}
+
+.run-bar-actions {
+  display: flex;
+  gap: 0.4rem;
+  flex-shrink: 0;
+}
+
+.run-bar-meta {
+  display: flex;
+  gap: 1rem;
+  margin-left: auto;
+}
+
+/* --- Tab strip ----------------------------------------------------- */
+
+.tab-strip {
+  display: flex;
+  gap: 0;
+  border-bottom: 1px solid var(--line);
+  overflow-x: auto;
+  scrollbar-width: none;
+}
+
+.tab-strip::-webkit-scrollbar { display: none; }
+
+.tab-btn {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  padding: 0.55rem 0.85rem;
+  border: none;
+  background: transparent;
+  color: var(--ink-secondary);
+  font-size: 0.82rem;
+  font-weight: 500;
+  white-space: nowrap;
+  transition: color 0.15s ease;
+}
+
+.tab-btn:hover { color: var(--ink); }
+
+.tab-btn.active {
+  color: var(--accent);
+}
+
+.tab-btn.active::after {
+  content: "";
+  position: absolute;
+  bottom: -1px;
+  left: 0.85rem;
+  right: 0.85rem;
+  height: 2px;
+  background: var(--accent);
+  border-radius: 1px;
+}
+
+.tab-badge {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 16px;
+  height: 16px;
+  padding: 0 4px;
+  border-radius: 999px;
+  font-size: 0.62rem;
+  font-weight: 700;
+  line-height: 1;
+}
+
+.tab-badge.warn { background: var(--warn-soft); color: var(--warn); }
+.tab-badge.danger { background: var(--danger-soft); color: var(--danger); }
+
+/* --- Tab content -------------------------------------------------- */
+
+.tab-content {
+  background: var(--bg-raised);
+  border: 1px solid var(--line);
+  border-top: none;
+  border-radius: 0 0 var(--radius) var(--radius);
+  padding: 1.5rem;
+  min-height: 300px;
+}
+
+/* --- Panel (generic raised surface) ------------------------------- */
+
+.panel {
+  background: var(--bg-raised);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  padding: 1.5rem;
+}
+
+.panel h2 {
+  margin: 0 0 1rem;
+  font-family: var(--serif);
+  font-size: 1.15rem;
+  font-weight: 500;
+  letter-spacing: -0.01em;
+  line-height: 1.2;
+}
+
+.panel h3 {
+  margin: 1.25rem 0 0.5rem;
+  font-family: var(--sans);
+  font-size: 0.92rem;
+  font-weight: 600;
+  line-height: 1.2;
+}
+
+.panel p { margin: 0.35rem 0; }
+
+.muted { color: var(--ink-secondary); }
+
+/* --- DAG graph ---------------------------------------------------- */
+
+.graph-split {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 1.5rem;
+  align-items: start;
+}
+
+.dag-graph {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));
+  gap: 0.5rem;
+}
+
+.dag-node {
+  display: flex;
+  flex-direction: column;
+  gap: 0.2rem;
+  padding: 0.6rem 0.75rem;
+  border: 1px solid var(--line);
+  border-left: 3px solid var(--ink-tertiary);
+  border-radius: var(--radius-sm);
+  background: var(--bg);
+  color: var(--ink-secondary);
+  text-align: left;
+  font-size: 0.82rem;
+  cursor: pointer;
+  transition: border-color 0.15s ease, background 0.15s ease;
+}
+
+.dag-node:hover { background: var(--bg-hover); }
+
+.dag-node.active {
+  border-color: var(--accent);
+  border-left-color: var(--accent);
+  background: var(--accent-soft);
+}
+
+.dag-node .node-title {
+  font-weight: 600;
+  color: var(--ink);
+  font-size: 0.8rem;
+  line-height: 1.3;
+}
+
+.dag-node .node-state {
+  font-size: 0.7rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.dag-node.state-completed { border-left-color: var(--ok); }
+.dag-node.state-active,
+.dag-node.state-running   { border-left-color: var(--ok); }
+.dag-node.state-blocked,
+.dag-node.state-manual_attention { border-left-color: var(--warn); }
+.dag-node.state-failed    { border-left-color: var(--danger); }
+.dag-node.state-ready     { border-left-color: var(--info); }
+.dag-node.state-queued     { border-left-color: var(--ink-tertiary); }
+
+/* --- Task detail -------------------------------------------------- */
+
+.task-detail h3 {
+  margin: 0 0 0.5rem;
+  font-family: var(--serif);
+  font-size: 1.05rem;
+  font-weight: 500;
+}
+
+.task-detail p {
+  margin: 0.25rem 0;
+  font-size: 0.88rem;
+}
+
+.task-detail .detail-line {
+  display: flex;
+  gap: 0.4rem;
+  margin: 0.2rem 0;
+  font-size: 0.84rem;
+}
+
+.task-detail .detail-line strong {
+  color: var(--ink);
+  flex-shrink: 0;
+}
+
+.task-detail .detail-line span,
+.task-detail .detail-line a {
+  font-family: var(--mono);
+  font-size: 0.78rem;
+  color: var(--ink-secondary);
+  word-break: break-all;
+}
+
+.task-detail .detail-line a { color: var(--accent); }
+.task-detail .detail-line a:hover { color: var(--accent-hover); }
+
+/* --- Decision panel ----------------------------------------------- */
+
+.decision-block {
+  padding: 1rem 0;
+  border-bottom: 1px solid var(--line);
+}
+
+.decision-block:last-of-type { border-bottom: none; }
+
+.decision-block h3 { margin: 0 0 0.35rem; }
+
+.decision-block textarea {
+  width: 100%;
+  min-height: 4rem;
+  padding: 0.5rem 0.65rem;
+  background: var(--bg-hover);
+  border: 1px solid var(--line);
+  border-radius: var(--radius-sm);
+  color: var(--ink);
+  font-size: 0.84rem;
+  font-family: var(--sans);
+  line-height: 1.5;
+  resize: vertical;
+  transition: border-color 0.15s ease;
+}
+
+.decision-block textarea:focus {
+  outline: none;
+  border-color: var(--accent);
+  box-shadow: 0 0 0 2px var(--accent-soft);
+}
+
+.decision-block ul {
+  margin: 0.5rem 0 0;
+  padding-left: 1.25rem;
+}
+
+.decision-block li {
+  font-size: 0.84rem;
+  color: var(--ink-secondary);
+  margin: 0.15rem 0;
+}
+
+/* --- Timeline ----------------------------------------------------- */
+
+.timeline {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+.timeline li {
+  display: grid;
+  grid-template-columns: auto 1fr;
+  gap: 0.35rem 0.75rem;
+  padding: 0.55rem 0;
+  border-bottom: 1px solid var(--line);
+  font-size: 0.84rem;
+}
+
+.timeline li:last-child { border-bottom: none; }
+
+.timeline .event-kind {
+  font-size: 0.65rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--accent);
+  padding: 0.1rem 0.4rem;
+  background: var(--accent-soft);
+  border-radius: 3px;
+  line-height: 1.4;
+  align-self: start;
+}
+
+.timeline .event-time {
+  font-family: var(--mono);
+  font-size: 0.72rem;
+  color: var(--ink-tertiary);
+  text-align: right;
+}
+
+.timeline .event-message {
+  grid-column: 1 / -1;
+  color: var(--ink-secondary);
+  line-height: 1.5;
+}
+
+/* --- Markdown / pre panels ---------------------------------------- */
+
+.markdown-panel .panel-head {
+  display: flex;
+  align-items: baseline;
+  gap: 1rem;
+  margin-bottom: 1rem;
+}
+
+.markdown-panel .panel-head h2 { margin: 0; }
+
+.markdown-panel .panel-head a {
+  font-size: 0.8rem;
+  font-weight: 500;
+}
+
+.markdown-panel pre,
+pre.markdown {
+  overflow-x: auto;
+  margin: 0;
+  padding: 1rem 1.25rem;
+  background: var(--bg-inset);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  line-height: 1.55;
+  font-family: var(--mono);
+  font-size: 0.8rem;
+  color: #c8c3ba;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+/* --- Delivery ----------------------------------------------------- */
+
+.delivery-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+.delivery-list li {
+  padding: 0.4rem 0;
+  border-bottom: 1px solid var(--line);
+}
+
+.delivery-list li:last-child { border-bottom: none; }
+
+.delivery-list a {
+  font-size: 0.88rem;
+  font-weight: 500;
+}
+
+/* --- Repo state --------------------------------------------------- */
+
+.pr-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+.pr-list li {
+  padding: 0.3rem 0;
+}
+
+.pr-list a { font-size: 0.86rem; }
+
+.lineage-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+.lineage-list li {
+  padding: 0.25rem 0;
+  font-size: 0.84rem;
+  font-family: var(--mono);
+  color: var(--ink-secondary);
+}
+
+/* --- Recovery ----------------------------------------------------- */
+
+.recovery-block {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.recovery-block p { font-size: 0.88rem; }
+
+/* --- Welcome / empty states --------------------------------------- */
+
+.empty-state {
+  text-align: center;
+  padding: 3rem 1rem;
+  color: var(--ink-tertiary);
+}
+
+.empty-state p {
+  font-size: 0.92rem;
+  max-width: 32rem;
+  margin: 0.5rem auto;
+}
+
+/* --- Responsive --------------------------------------------------- */
+
+@media (max-width: 900px) {
+  .shell { padding: 0 1rem 1.5rem; }
+
+  .topbar {
+    flex-wrap: wrap;
+    gap: 0.75rem;
+  }
+
+  .body {
+    grid-template-columns: 1fr;
+    gap: 1rem;
+  }
+
+  .sidebar {
+    position: static;
+    max-height: none;
+  }
+
+  .graph-split {
+    grid-template-columns: 1fr;
+  }
+
+  .run-bar {
+    flex-wrap: wrap;
+    gap: 0.75rem;
+  }
+
+  .run-bar-meta { margin-left: 0; }
+
+  .tab-strip { gap: 0; }
+}
+
+/* --- Entrance animation ------------------------------------------- */
+
+@media (prefers-reduced-motion: no-preference) {
+  .topbar,
+  .sidebar,
+  .main-area {
+    animation: fadeUp 0.35s ease both;
+  }
+
+  .sidebar   { animation-delay: 0.04s; }
+  .main-area { animation-delay: 0.08s; }
+}
+
+@keyframes fadeUp {
+  from { opacity: 0; transform: translateY(6px); }
+  to   { opacity: 1; transform: translateY(0); }
+}
diff --git a/docs/getting-started.md b/docs/getting-started.md
index f625bed..d1ad3af 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -100,11 +100,10 @@ Kick off the most recent pending run:
 night-shift start
 ```
 
-You can also target a specific run or open the local dashboard:
+You can also target a specific run:
 
 ```sh
 night-shift start --run run-123
-night-shift start --ui
 ```
 
 `start` is execution-only. It uses the execution agent, environment, and brief
@@ -138,6 +137,23 @@ report directly, including per-task runtime manifest and handoff paths once
 worktrees have been prepared. `provenance` prints the run's evidence ledger
 from the saved artifact graph.
 
+## Dashboard
+
+Night Shift includes a browser-native dashboard for the full operator
+workflow. Instead of cycling through CLI commands, run:
+
+```sh
+night-shift dash
+```
+
+Dash binds to `127.0.0.1`, prints a localhost URL, and opens a control surface
+where you can initialize, plan, inspect the task DAG, start and resume runs,
+resolve blocked decisions, and audit reports and provenance -- all from the
+browser with live SSE-driven updates.
+
+The CLI commands above remain available for automation and scripting. Dash is
+the intended human-first entrypoint.
+
 ## Supporting Flows
 
 If planning produced manual-attention tasks, record the answers and let Night
@@ -154,7 +170,6 @@ If a run was interrupted, resume from the saved journal:
 night-shift doctor
 night-shift resume --explain
 night-shift resume
-night-shift resume --ui
 ```
 
 `doctor` is the dry recovery pass. It classifies each task as
@@ -177,5 +192,7 @@ If you want a dry proof that the end-to-end harness is wired correctly:
 
 ```sh
 night-shift --demo
-night-shift --demo --ui
 ```
+
+The demo launches `night-shift dash` and drives the browser-backed start flow
+through Dash's HTTP surface.
diff --git a/docs/index.md b/docs/index.md
index d746ce3..7a91462 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -32,11 +32,17 @@ night-shift status
 night-shift report
 ```
 
+Or use the browser-native dashboard for the full operator workflow:
+
+```sh
+night-shift dash
+```
+
 Use `resolve` when planning needs human decisions, `resume` when a run was
 interrupted, `doctor` or `resume --explain` when you want a dry recovery read,
 `plan --from-reviews` when open Night Shift PRs need a fresh successor stack,
 and `reset` when you need to eject the repo-local control plane and start
-over.
+over. All of these flows are also available from the dashboard.
 
 ## Repository
 
diff --git a/docs/providers-and-delivery.md b/docs/providers-and-delivery.md
index 717d5ee..6795eef 100644
--- a/docs/providers-and-delivery.md
+++ b/docs/providers-and-delivery.md
@@ -111,17 +111,13 @@ leave that disabled and still use the PR-body overlay.
 
 ## Dashboard
 
-The local dashboard is intentionally narrow in scope. It binds to `127.0.0.1`,
-prefers port `8787`, and serves a monitor-only UI for:
+Dash is the repo-local browser front door. It binds to `127.0.0.1`, asks the
+OS for an open local port, and serves:
 
-- run history
-- summary metadata for the selected run
+- run history and selected-run bootstrap state
 - repo-state summary for review-driven runs, including snapshot time and drift
-- task status
-- event timeline
-- report content
-
-There are no browser-side mutation controls.
+- DAG, task, timeline, report, provenance, and raw artifact panels
+- browser-side init, plan, start, resume, and resolve actions
 
 ## Demo Mode
 
diff --git a/docs/run-lifecycle.md b/docs/run-lifecycle.md
index 7e0652f..678527a 100644
--- a/docs/run-lifecycle.md
+++ b/docs/run-lifecycle.md
@@ -90,7 +90,6 @@ and the next action becomes `night-shift start`.
 night-shift doctor
 night-shift resume --explain
 night-shift resume
-night-shift resume --run run-123 --ui
 ```
 
 Night Shift reloads the saved run, validates the saved environment, recovers
@@ -184,22 +183,26 @@ attention with both the original and repair artifacts recorded.
 
 ## Dashboard
 
-The dashboard is monitor-only:
+Dash is the standalone browser entrypoint:
 
 ```sh
-night-shift start --ui
-night-shift resume --ui
+night-shift dash
 ```
 
-Night Shift binds to `127.0.0.1`, prefers port `8787`, and serves:
+Night Shift binds to `127.0.0.1`, asks the OS for an open local port, and
+serves a browser-native front door for:
 
 - run history for the current repository
 - run summary metadata
 - repo-state summary for review-driven runs, including open PR counts and drift
 - confidence posture and provenance path
 - task status
+- DAG graph and synchronized task detail
+- browser-driven init, plan, start, resume, and resolve flows
 - event timeline
 - report content
+- provenance and raw artifact links
 
-There are no browser-side controls for starting or resuming runs in this
-version.
+Execution and recovery now happen from the browser actions exposed by Dash.
+The old `dash --start`, `dash --resume`, `start --ui`, and `resume --ui`
+entrypoints are gone.
diff --git a/night-shift-dash-prd.md b/night-shift-dash-prd.md
new file mode 100644
index 0000000..3707b02
--- /dev/null
+++ b/night-shift-dash-prd.md
@@ -0,0 +1,480 @@
+# Night Shift Dash PRD
+
+## Summary
+
+`night-shift dash` will become the new human-first front door for Night Shift.
+Instead of a monitor-only `--ui` mode attached to `start` and `resume`, Dash
+will start a localhost web application that lets an operator initialize a repo,
+plan work, inspect the task DAG before execution, start and resume runs, resolve
+planning decisions, and audit the resulting artifacts in realtime.
+
+This is a functional product surface, not a visual design exercise. The v1 goal
+is a solid interaction shape and a trustworthy execution/audit story.
+
+### Locked decisions
+
+- Dash is a full front door, not a read-only monitor.
+- The UI stack is pure Gleam/Lustre by default.
+- Realtime updates use Server-Sent Events (SSE), not polling-first or
+  websocket-first transport.
+- The `dash` process owns execution of Night Shift workflows directly rather
+  than shelling out to separate CLI subprocesses or introducing a new daemon.
+- v1 is localhost-only, single-user, and current-repo-only.
+- `start --ui` and `resume --ui` are removed in favor of `night-shift dash`.
+- Dash includes guided init, browser-based planning input, browser-based
+  decision resolution, DAG visualization, and audit/report/provenance surfaces.
+
+## Problem
+
+The current `--ui` flag is too narrow to justify being a first-class product
+surface:
+
+- it is monitor-only
+- it is attached to `start` and `resume` rather than being a front door
+- it relies on polling rather than a proper realtime model
+- it does not help with init, planning, decision resolution, or resume
+- it does not present the DAG as a primary object before execution begins
+- it does not make audit, reports, provenance, and PR review links feel like a
+  coherent operator experience
+
+Night Shift already persists enough structured state to support a richer GUI:
+run journals, events, reports, provenance artifacts, review-driven repo-state
+snapshots, task state, worktree/runtime metadata, and delivered PR information.
+The missing piece is a proper UI/control-plane surface that is shaped around how
+an operator actually uses the tool.
+
+## Goals
+
+- Make Night Shift operable primarily from the browser.
+- Show repo state, run state, and DAG state before execution starts and while a
+  run is live.
+- Make status, report, provenance, and raw artifacts easy to inspect and audit.
+- Link directly to task PRs and review-relevant context.
+- Preserve the repo-local, inspectable, durable character of Night Shift.
+- Keep the first version functionally solid rather than visually polished.
+
+## Non-Goals
+
+- Multi-repo orchestration or a cross-repo control plane.
+- Remote access, shared sessions, or multi-user coordination.
+- Authentication/session hardening beyond the localhost-only model.
+- A separate persistent daemon or background service shared with the CLI.
+- Pixel-perfect design-system work, advanced theming, or a polished brand pass.
+
+## Primary User
+
+The primary user is the local operator running Night Shift inside one checked-out
+repository on their own machine. This operator needs a reliable way to:
+
+- initialize and configure Night Shift for the repo
+- create or refresh a plan
+- understand the DAG before starting it
+- watch execution progress live
+- inspect repo-state drift and review-driven lineage
+- answer blocked planning questions
+- audit reports, provenance, logs, and PR handoff after the run
+
+## Product Shape
+
+Dash is a repo-local web app started by:
+
+```sh
+night-shift dash
+```
+
+The command launches a localhost server bound to `127.0.0.1`, opens or prints a
+browser URL, and hosts a single-repo workspace for the current repository. The
+browser is the primary control surface for operator actions. Existing read-only
+CLI surfaces such as `status`, `report`, and `provenance` remain available and
+must continue to work against runs created or driven through Dash.
+
+The workspace should be organized around the following persistent areas:
+
+- Repo/workspace header
+- Current run summary
+- DAG graph plus synchronized task list/detail pane
+- Repo-state/review context panel when available
+- Live event timeline
+- Status/report/provenance/artifact inspection area
+
+## Operator Journeys
+
+### 1. Uninitialized repo -> guided init
+
+When the repo has not been initialized, Dash should detect the missing
+`.night-shift` control plane and present an onboarding flow instead of a broken
+empty workspace.
+
+The init flow must support:
+
+- selecting the default provider
+- selecting a model available to that provider
+- choosing whether to generate `./.night-shift/worktree-setup.toml`
+- confirming resulting configuration
+
+On successful init, Dash transitions directly into the normal workspace without
+requiring the operator to restart the command.
+
+### 2. Notes planning via browser
+
+Dash should provide a planning surface with:
+
+- a notes textarea for pasted planning input
+- an optional brief path field
+- a plan action
+- a `Plan From Reviews` action
+
+The operator can plan from pasted notes, reviews, or both. After planning, Dash
+must render the resulting pending DAG before execution begins.
+
+### 3. Inspect pending DAG before start
+
+After planning, the operator must be able to inspect:
+
+- task dependency shape
+- task kind and execution mode
+- readiness/blocked/manual-attention state
+- acceptance/demo details
+- review-driven replacement lineage when present
+
+The DAG should be viewable both as a graph and as a structured list so that the
+operator can understand both the topology and the exact details.
+
+### 4. Start run and watch live execution
+
+The operator starts execution from Dash. Once started, the UI must live-update:
+
+- run status
+- task state transitions
+- follow-up task insertion or DAG refreshes
+- event timeline
+- PR delivery updates, including direct PR links
+- report/provenance availability as artifacts land
+
+The operator should not need to refresh manually to track an active run.
+
+### 5. Resolve blocked planning decisions in browser
+
+If a run blocks on manual-attention planning decisions, Dash must present those
+decision requests as browser-native forms, including:
+
+- question
+- rationale
+- structured options when available
+- recommended option when available
+- freeform answer input when allowed
+
+Submitting decisions should trigger replanning inside Dash and update the
+displayed DAG without dropping the current workspace context.
+
+### 6. Resume interrupted run
+
+If a run was interrupted, Dash should expose resume affordances and recovery
+context. The operator should be able to inspect recovery signals and then resume
+the run from the browser with live updates continuing over the same Dash
+session.
+
+### 7. Audit completed, blocked, or failed runs
+
+After a run finishes or blocks, Dash must remain useful as an audit surface. It
+should make it easy to inspect:
+
+- final status
+- timeline of events
+- rendered report
+- provenance artifact
+- raw logs/artifacts
+- task-level worktree/runtime context
+- delivered PRs and lineage
+- review-driven repo-state drift when applicable
+
+Refreshing the page must not destroy access to this audit surface.
+
+## UX Requirements
+
+### Workspace shell
+
+Dash should present a single-repo workspace with enough context to orient the
+operator immediately:
+
+- repo root
+- initialization state
+- active or latest run
+- high-level next action
+- connection status for the realtime stream
+
+### DAG visualization
+
+The minimum acceptable DAG visualization is a graph-plus-list hybrid:
+
+- a node-edge graph that shows dependency shape
+- a synchronized task list/detail pane for exact inspection
+- selecting a task in either surface highlights it in the other
+- task state is visible in both surfaces
+
+The list/detail pane is not a fallback; it is a required first-class part of the
+experience for accessibility, precision, and auditability.
+
+### Repo-state panel
+
+For review-driven runs, Dash must show repo-state context including:
+
+- captured open PR count
+- captured actionable PR count
+- snapshot capture time
+- current open/actionable counts when live inspection is available
+- drift status and drift details when known
+- actionable PR list
+- impacted PR list
+
+### Timeline
+
+Dash must present a first-class event timeline that updates live during active
+runs and remains readable afterward. Timeline events should be filterable at
+least by run-wide vs task-scoped events.
+
+### Report, status, provenance, and artifacts
+
+Dash should expose status, report, provenance, and raw artifacts as primary
+surfaces, not as buried debug links. The operator should be able to inspect:
+
+- human-readable status summary
+- rendered report
+- provenance path and rendered provenance view
+- raw artifact links/downloads for report, provenance, and logs
+
+### Task detail
+
+Per-task detail should include, when available:
+
+- title and task id
+- description, acceptance criteria, and demo plan
+- task kind and execution mode
+- dependencies and dependents
+- current state
+- branch name
+- PR number
+- PR URL
+- worktree path
+- runtime context summary
+- summary/output text
+- replacement lineage context for review-driven work
+
+## Realtime Model
+
+Dash uses Server-Sent Events as the default realtime transport.
+
+### Realtime requirements
+
+- The browser connects to an SSE stream after loading the workspace.
+- The SSE stream is the primary source of live updates during an active Dash
+  session.
+- Browser commands use plain HTTP actions rather than long-lived bidirectional
+  sockets.
+- Refreshing the page reconnects to the SSE stream and reloads the current
+  repo/run state from durable storage.
+- Polling is not the primary model in v1.
+
+### Event categories
+
+The SSE contract must support structured events for:
+
+- repo/run bootstrap state
+- task state transitions
+- timeline events
+- DAG refreshes after planning or replanning
+- delivery updates, including PR URLs
+- run completion, blockage, or failure
+
+The implementation does not need to freeze final endpoint paths in this PRD,
+but it must commit to a structured command API plus a structured SSE event
+model.
+
+## Architecture
+
+### Topology
+
+- `night-shift dash` starts a localhost web server bound to `127.0.0.1`.
+- The Dash process owns command execution for init, plan, resolve, start, and
+  resume.
+- The web app is implemented with Lustre in a Gleam-native stack.
+- Existing journal and artifact persistence remain the source of truth.
+- Live session state augments persisted run state for realtime rendering but
+  does not replace the journal as the durable record.
+
+### Reuse strategy
+
+The implementation should bias toward reusing the existing Night Shift domain
+and usecase layers rather than bypassing them:
+
+- configuration and repo initialization logic
+- planning and replanning flows
+- resolve flow and decision model
+- start and resume orchestration
+- status/report/provenance rendering
+- journal and artifact persistence
+- repo-state and review-lineage projections
+
+The current minimal dashboard/server may be evolved or replaced, but the new
+Dash architecture should preserve existing durable state and existing business
+rules wherever possible.
+
+### Execution ownership
+
+Dash owns execution directly inside its process. This means:
+
+- browser actions do not shell out to `night-shift` subprocesses
+- CLI output parsing is not the integration strategy
+- a new daemon/control-plane service is not introduced for v1
+
+This keeps the architecture closer to a pure application runtime and avoids the
+usual class of bugs produced by treating stringly subprocess output as an API.
+
+## Public Interface Changes
+
+### CLI changes
+
+Add:
+
+- `night-shift dash`
+
+Remove:
+
+- `night-shift start --ui`
+- `night-shift resume --ui`
+
+Keep:
+
+- `night-shift init`
+- `night-shift plan`
+- `night-shift resolve`
+- `night-shift start`
+- `night-shift resume`
+- `night-shift status`
+- `night-shift report`
+- `night-shift provenance`
+- other existing read/repair flows
+
+The CLI remains a valid automation and escape-hatch surface, but Dash becomes
+the intended human-first GUI entrypoint.
+
+### Browser actions
+
+Dash must expose browser-driven actions for:
+
+- init
+- plan with notes textarea and optional doc path
+- plan from reviews
+- resolve decisions
+- start
+- resume
+
+### API contract shape
+
+The implementation must define:
+
+- a structured command API for browser actions
+- a structured SSE stream for live updates
+- a state bootstrap endpoint or equivalent mechanism for initial page load
+
+Exact endpoint names are intentionally left open, but the contract must support
+the workflows described in this document without scraping CLI text.
+
+## Data And State Requirements
+
+Dash must be able to render the following from current state plus live updates:
+
+- repo initialization status
+- latest and active run identity
+- run status and timestamps
+- task DAG, task metadata, and task state
+- decision requests and recorded decisions
+- repo-state review snapshot and drift
+- lineage for superseded PR work
+- timeline events
+- report and provenance locations/content
+- PR delivery information, including URL
+- task worktree and runtime context
+
+Where data already exists in persisted Night Shift artifacts, Dash should
+consume it rather than inventing a parallel store.
+
+## Audit Requirements
+
+Dash is not only an execution view; it is an audit surface.
+
+v1 must include:
+
+- a first-class event timeline
+- provenance visibility
+- links to report, provenance, and raw log artifacts
+- PR links from delivered tasks
+- review-driven repo snapshot, actionable/impacted PR lists, and drift display
+- durable post-refresh access to completed, blocked, and failed runs
+
+The audit story should privilege inspectability over clever animation.
+
+## Error Handling And Recovery
+
+Dash must handle the following cleanly:
+
+- local server startup failures
+- inability to bind the localhost port
+- malformed or failed command submissions
+- SSE disconnect/reconnect
+- browser refresh during active execution
+- blocked runs
+- failed runs
+- interrupted runs that can be resumed
+- runs that are no longer safe to resume
+
+The UI should always preserve or restore enough context that the operator can
+understand what happened and what to do next.
+
+## Success Criteria
+
+Dash is successful in v1 if a Night Shift operator can do the complete common
+workflow from the browser:
+
+1. initialize the repo if needed
+2. plan work from notes or reviews
+3. inspect the DAG before execution
+4. start the run
+5. watch it update live
+6. resolve blocked planning decisions in the browser if necessary
+7. resume if interrupted
+8. audit the result, artifacts, and PRs afterward
+
+## Acceptance Scenarios
+
+The implementation must satisfy the following acceptance scenarios:
+
+1. Running `night-shift dash` on an uninitialized repo opens a guided init flow
+   and can complete initialization without restarting Dash.
+2. Planning from pasted notes creates a pending run and renders the planned DAG
+   before execution begins.
+3. Planning from reviews renders repo-state snapshot data and
+   actionable/impacted PR context.
+4. Starting from Dash streams live task and timeline updates and eventually
+   shows delivered PR links.
+5. A blocked run can be resolved fully from the browser and replans without
+   losing workspace context.
+6. An interrupted run can be resumed from Dash with live updates.
+7. Completed, blocked, and failed runs all remain auditable after refresh via
+   report, provenance, timeline, and artifact links.
+8. The DAG view remains synchronized between graph and list/detail panes.
+9. Dash binds only to localhost and operates only on the current repo.
+10. CLI read commands still work against runs created and driven through Dash.
+
+## Assumptions And Defaults
+
+- Output artifact: `night-shift-dash-prd.md` at the repo root.
+- v1 is local-only, single-user, and repo-local.
+- Realtime means SSE-driven live updates, not websocket-first and not
+  polling-first.
+- “Full front door” includes guided init and browser-based decision resolution,
+  not merely `start` and `resume`.
+- Visual polish is explicitly secondary to information architecture,
+  interaction shape, and auditability.
+- Lustre is the intended UI framework, and a pure Gleam/Lustre bias is a
+  strategic constraint rather than an implementation afterthought.
diff --git a/scripts/build_dash_assets.sh b/scripts/build_dash_assets.sh
new file mode 100755
index 0000000..b7caeeb
--- /dev/null
+++ b/scripts/build_dash_assets.sh
@@ -0,0 +1,36 @@
+#!/bin/sh
+set -eu
+
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+REPO_ROOT=$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd)
+DASH_ROOT="$REPO_ROOT/dash_web"
+OUTPUT_ROOT="${1:-$REPO_ROOT/build/dash-assets}"
+
+if ! command -v gleam >/dev/null 2>&1; then
+  echo "gleam is required to build dashboard assets" >&2
+  exit 1
+fi
+
+if [ ! -f "$DASH_ROOT/gleam.toml" ]; then
+  echo "dash_web/gleam.toml is missing" >&2
+  exit 1
+fi
+
+rm -rf "$OUTPUT_ROOT"
+mkdir -p "$OUTPUT_ROOT/app"
+
+(
+  cd "$DASH_ROOT"
+  gleam build --target javascript
+)
+
+cp -R "$DASH_ROOT/build/dev/javascript/." "$OUTPUT_ROOT/app/"
+cp "$DASH_ROOT/static/dash.css" "$OUTPUT_ROOT/dash.css"
+
+cat > "$OUTPUT_ROOT/dash.js" <<'EOF'
+import { main } from "./app/dash_web/dash_web.mjs";
+
+main();
+EOF
+
+echo "Built dashboard assets in $OUTPUT_ROOT"
diff --git a/scripts/build_release_bundle.sh b/scripts/build_release_bundle.sh
index f93bc1b..3a9ad03 100755
--- a/scripts/build_release_bundle.sh
+++ b/scripts/build_release_bundle.sh
@@ -46,6 +46,7 @@ rm -rf "$bundle_dir" "$archive_path" "$checksum_path"
 
 cd "$REPO_ROOT"
 gleam export erlang-shipment
+sh "$REPO_ROOT/scripts/build_dash_assets.sh" "$REPO_ROOT/build/dash-assets"
 
 erlang_root=$(
   erl -eval 'io:format("~s", [code:root_dir()]), halt().' -noshell
@@ -59,6 +60,7 @@ fi
 mkdir -p "$bundle_dir"
 cp -R "$REPO_ROOT/build/erlang-shipment" "$bundle_dir/shipment"
 cp -R "$erlang_root" "$bundle_dir/erlang"
+cp -R "$REPO_ROOT/build/dash-assets" "$bundle_dir/dash-assets"
 
 if command -v xattr >/dev/null 2>&1; then
   xattr -cr "$bundle_dir" 2>/dev/null || true
@@ -69,6 +71,7 @@ cat > "$bundle_dir/night-shift" <<'EOF'
 set -eu
 
 BASE=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+NIGHT_SHIFT_DASH_ASSET_ROOT="$BASE/dash-assets" \
 ERL_ROOTDIR="$BASE/erlang" \
   exec "$BASE/erlang/bin/erl" \
     -pa "$BASE"/shipment/*/ebin \
diff --git a/src/night_shift/app.gleam b/src/night_shift/app.gleam
index ed9be9a..8c9a1f9 100644
--- a/src/night_shift/app.gleam
+++ b/src/night_shift/app.gleam
@@ -12,9 +12,9 @@ import gleam/string
 import night_shift/agent_config
 import night_shift/cli
 import night_shift/config
+import night_shift/dash/session as dash_session
 import night_shift/demo
 import night_shift/git
-import night_shift/infra/dashboard_session
 import night_shift/infra/decision_prompt
 import night_shift/infra/init_prompt
 import night_shift/infra/reset_guard
@@ -68,6 +68,7 @@ pub fn run(command: types.Command) -> Nil {
       }
     types.Reset(assume_yes, force) ->
       io.println(reset(repo_root, assume_yes, force))
+    types.Dash(run) -> dash(repo_root, run)
     _ ->
       case load_initialized_repo_config(repo_root) {
         Error(message) -> io.println(message)
@@ -129,8 +130,7 @@ fn run_initialized_command(
           )
         Error(message) -> message
       })
-    types.Start(run, False) -> io.println(start(repo_root, run, config))
-    types.Start(run, True) -> start_with_ui(repo_root, run, config)
+    types.Start(run) -> io.println(start(repo_root, run, config))
     types.Status(run) -> io.println(status(repo_root, run, config))
     types.Report(run) -> io.println(report(repo_root, run, config))
     types.Provenance(run, task_id, format) ->
@@ -138,10 +138,8 @@ fn run_initialized_command(
     types.Doctor(run) -> io.println(doctor(repo_root, run, config))
     types.Resolve(run, task_id, action) ->
       io.println(resolve(repo_root, run, task_id, action, config))
-    types.Resume(run, False, False) ->
-      io.println(resume(repo_root, run, config))
-    types.Resume(run, True, False) -> resume_with_ui(repo_root, run, config)
-    types.Resume(run, False, True) -> io.println(doctor(repo_root, run, config))
+    types.Resume(run, False) -> io.println(resume(repo_root, run, config))
+    types.Resume(run, True) -> io.println(doctor(repo_root, run, config))
     _ -> io.println("Unsupported command.")
   }
 }
@@ -350,23 +348,8 @@ fn reset(repo_root: String, assume_yes: Bool, force: Bool) -> String {
   }
 }
 
-fn start_with_ui(
-  repo_root: String,
-  selector: types.RunSelector,
-  config: types.Config,
-) -> Nil {
-  case dashboard_session.start(repo_root, selector, config) {
-    Ok(Nil) -> Nil
-    Error(message) -> io.println(message)
-  }
-}
-
-fn resume_with_ui(
-  repo_root: String,
-  run: types.RunSelector,
-  config: types.Config,
-) -> Nil {
-  case dashboard_session.resume(repo_root, run, config) {
+fn dash(repo_root: String, selector: types.RunSelector) -> Nil {
+  case dash_session.view(repo_root, selector) {
     Ok(Nil) -> Nil
     Error(message) -> io.println(message)
   }
diff --git a/src/night_shift/cli.gleam b/src/night_shift/cli.gleam
index 0e77764..556fdb2 100644
--- a/src/night_shift/cli.gleam
+++ b/src/night_shift/cli.gleam
@@ -10,19 +10,20 @@ pub fn usage() -> String {
   <> "\n"
   <> "Commands:\n"
   <> "  --demo [--ui]\n"
+  <> "  dash [--run <id>|latest]\n"
   <> "  init [--profile <name>] [--provider <codex|cursor>] [--model <id>] [--reasoning <low|medium|high|xhigh>] [--yes] [--generate-setup]\n"
   <> "    Prompts interactively for provider, model, and initial worktree setup when those answers are not supplied.\n"
   <> "  reset [--yes] [--force]\n"
   <> "  plan --notes <file-or-inline-text> [--doc <path>] [--profile <name>] [--provider <codex|cursor>] [--model <id>] [--reasoning <low|medium|high|xhigh>]\n"
   <> "  plan --from-reviews [--notes <file-or-inline-text>] [--doc <path>] [--profile <name>] [--provider <codex|cursor>] [--model <id>] [--reasoning <low|medium|high|xhigh>]\n"
-  <> "  start [--run <id>|latest] [--ui]\n"
+  <> "  start [--run <id>|latest]\n"
   <> "  status [--run <id>|latest]\n"
   <> "  report [--run <id>|latest]\n"
   <> "  provenance [--run <id>|latest] [--task <task-id>] [--format <json|md>]\n"
   <> "  doctor [--run <id>|latest]\n"
   <> "  resolve [--run <id>|latest]\n"
   <> "  resolve [--run <id>|latest] --task <task-id> [--inspect|--continue|--complete|--abandon]\n"
-  <> "  resume [--run <id>|latest] [--ui|--explain]\n"
+  <> "  resume [--run <id>|latest] [--explain]\n"
 }
 
 /// Parse raw command-line arguments into a `Command`.
@@ -31,7 +32,7 @@ pub fn usage() -> String {
 ///
 /// ```gleam
 /// > parse(["start", "--run", "latest"])
-/// Ok(types.Start(types.LatestRun, False))
+/// Ok(types.Start(types.LatestRun))
 /// ```
 ///
 /// ```gleam
@@ -48,6 +49,7 @@ pub fn parse(args: List(String)) -> Result(types.Command, String) {
         ["init", ..rest] -> parse_init(rest)
         ["reset", ..rest] -> parse_reset(rest)
         ["plan", ..rest] -> parse_plan(rest)
+        ["dash", ..rest] -> parse_dash(rest)
         ["start", ..rest] -> parse_start(rest)
         ["status", ..rest] -> parse_run_lookup(rest, types.Status)
         ["report", ..rest] -> parse_run_lookup(rest, types.Report)
@@ -224,7 +226,24 @@ fn parse_init_flags(
 }
 
 fn parse_start(args: List(String)) -> Result(types.Command, String) {
-  parse_start_flags(args, types.LatestRun, False)
+  parse_start_flags(args, types.LatestRun)
+}
+
+fn parse_dash(args: List(String)) -> Result(types.Command, String) {
+  case args {
+    [] -> Ok(types.Dash(types.LatestRun))
+    ["--run", "latest"] -> Ok(types.Dash(types.LatestRun))
+    ["--run", run_id] -> Ok(types.Dash(types.RunId(run_id)))
+    ["--start", ..] ->
+      Error(
+        "`night-shift dash --start` was removed; open Dash and use the Start button in the browser.",
+      )
+    ["--resume", ..] ->
+      Error(
+        "`night-shift dash --resume` was removed; open Dash and use the Resume button in the browser.",
+      )
+    [flag, ..] -> Error("Unsupported flag: " <> flag)
+  }
 }
 
 fn parse_reset(args: List(String)) -> Result(types.Command, String) {
@@ -247,21 +266,21 @@ fn parse_reset_flags(
 fn parse_start_flags(
   args: List(String),
   run: types.RunSelector,
-  ui_enabled: Bool,
 ) -> Result(types.Command, String) {
   case args {
-    [] -> Ok(types.Start(run, ui_enabled))
-    ["--run", "latest", ..rest] ->
-      parse_start_flags(rest, types.LatestRun, ui_enabled)
-    ["--run", run_id, ..rest] ->
-      parse_start_flags(rest, types.RunId(run_id), ui_enabled)
-    ["--ui", ..rest] -> parse_start_flags(rest, run, True)
+    [] -> Ok(types.Start(run))
+    ["--run", "latest", ..rest] -> parse_start_flags(rest, types.LatestRun)
+    ["--run", run_id, ..rest] -> parse_start_flags(rest, types.RunId(run_id))
+    ["--ui", ..] ->
+      Error(
+        "`start --ui` was replaced by `night-shift dash`, which now owns the browser flow.",
+      )
     [flag, ..] -> Error("Unsupported start flag: " <> flag)
   }
 }
 
 fn parse_resume(args: List(String)) -> Result(types.Command, String) {
-  parse_resume_flags(args, types.LatestRun, False, False)
+  parse_resume_flags(args, types.LatestRun, False)
 }
 
 fn parse_resolve(args: List(String)) -> Result(types.Command, String) {
@@ -325,21 +344,19 @@ fn parse_resolve_action(
 fn parse_resume_flags(
   args: List(String),
   run: types.RunSelector,
-  ui_enabled: Bool,
   explain_only: Bool,
 ) -> Result(types.Command, String) {
   case args {
-    [] ->
-      case ui_enabled && explain_only {
-        True -> Error("`resume --explain` cannot be combined with `--ui`.")
-        False -> Ok(types.Resume(run, ui_enabled, explain_only))
-      }
+    [] -> Ok(types.Resume(run, explain_only))
     ["--run", "latest", ..rest] ->
-      parse_resume_flags(rest, types.LatestRun, ui_enabled, explain_only)
+      parse_resume_flags(rest, types.LatestRun, explain_only)
     ["--run", run_id, ..rest] ->
-      parse_resume_flags(rest, types.RunId(run_id), ui_enabled, explain_only)
-    ["--ui", ..rest] -> parse_resume_flags(rest, run, True, explain_only)
-    ["--explain", ..rest] -> parse_resume_flags(rest, run, ui_enabled, True)
+      parse_resume_flags(rest, types.RunId(run_id), explain_only)
+    ["--ui", ..] ->
+      Error(
+        "`resume --ui` was replaced by `night-shift dash`, which now owns the browser flow.",
+      )
+    ["--explain", ..rest] -> parse_resume_flags(rest, run, True)
     [flag, ..] -> Error("Unsupported flag: " <> flag)
   }
 }
diff --git a/src/night_shift/dash/api.gleam b/src/night_shift/dash/api.gleam
new file mode 100644
index 0000000..4f7b2c1
--- /dev/null
+++ b/src/night_shift/dash/api.gleam
@@ -0,0 +1,498 @@
+import filepath
+import gleam/dynamic/decode
+import gleam/json
+import gleam/list
+import gleam/option.{type Option, None, Some}
+import gleam/result
+import night_shift/agent_config
+import night_shift/config
+import night_shift/dash/projection
+import night_shift/dash/session
+import night_shift/journal
+import night_shift/project
+import night_shift/provider_models
+import night_shift/system
+import night_shift/types
+import night_shift/usecase/init as init_usecase
+import night_shift/usecase/plan as plan_usecase
+import night_shift/usecase/resolve as resolve_usecase
+import night_shift/usecase/resume as resume_usecase
+import night_shift/usecase/start as start_usecase
+import simplifile
+
+pub fn workspace_json(
+  repo_root: String,
+  requested_run_id: Option(String),
+) -> Result(String, String) {
+  let #(resolved_config, initialized) = load_repo_config(repo_root)
+  projection.workspace_json(
+    repo_root,
+    requested_run_id,
+    resolved_config,
+    initialized,
+    session.command_state(repo_root),
+  )
+}
+
+pub fn init_models_json(
+  repo_root: String,
+  provider_name: String,
+) -> Result(String, String) {
+  use provider <- result.try(types.provider_from_string(provider_name))
+  use models <- result.try(provider_models.list_models(provider, repo_root))
+  Ok(
+    json.object([
+      #("provider", json.string(provider_name)),
+      #(
+        "models",
+        json.array(models, fn(model) {
+          json.object([
+            #("id", json.string(model.id)),
+            #("label", json.string(model.label)),
+            #("is_default", json.bool(model.is_default)),
+          ])
+        }),
+      ),
+      #("default_index", json.int(provider_models.default_index(models))),
+    ])
+    |> json.to_string,
+  )
+}
+
+pub fn init_action(repo_root: String, body: String) -> Result(String, String) {
+  use request <- result.try(decode_body(body, init_request_decoder()))
+  let #(base_config, _) = load_repo_config(repo_root)
+  let overrides =
+    types.AgentOverrides(
+      profile: request.profile,
+      provider: Some(request.provider),
+      model: Some(request.model),
+      reasoning: request.reasoning,
+    )
+
+  use result_view <- result.try(
+    init_usecase.execute(
+      repo_root,
+      base_config,
+      overrides,
+      request.generate_setup,
+      True,
+      fn(_, _) { Ok(request.provider) },
+      fn(_, _, _, _) { Ok(request.model) },
+      fn(_, _, _) { Ok(request.generate_setup) },
+    ),
+  )
+
+  Ok(command_response_json(
+    "Initialization complete. " <> result_view.next_action,
+    result_view.next_action,
+    None,
+  ))
+}
+
+pub fn plan_action(
+  repo_root: String,
+  body: String,
+  from_reviews: Bool,
+) -> Result(String, String) {
+  let resolved_config = require_initialized_config(repo_root)
+  use config_value <- result.try(resolved_config)
+  use request <- result.try(decode_body(body, plan_request_decoder()))
+  let overrides = request.overrides
+  use planning_agent <- result.try(agent_config.resolve_plan_agent(
+    config_value,
+    overrides,
+  ))
+  use view <- result.try(plan_usecase.execute(
+    repo_root,
+    request.notes,
+    from_reviews,
+    request.doc_path,
+    planning_agent,
+    config_value,
+  ))
+  Ok(command_response_json(
+    "Planning complete.",
+    view.next_action,
+    Some(view.run.run_id),
+  ))
+}
+
+pub fn start_command(
+  repo_root: String,
+  run_id: String,
+) -> Result(String, String) {
+  use config_value <- result.try(require_initialized_config(repo_root))
+  use view <- result.try(start_usecase.execute(
+    repo_root,
+    types.RunId(run_id),
+    config_value,
+  ))
+  Ok(command_response_json(
+    "Start finished.",
+    view.next_action,
+    Some(view.run.run_id),
+  ))
+}
+
+pub fn resume_command(
+  repo_root: String,
+  run_id: String,
+) -> Result(String, String) {
+  use config_value <- result.try(require_initialized_config(repo_root))
+  use view <- result.try(resume_usecase.execute(
+    repo_root,
+    types.RunId(run_id),
+    config_value,
+  ))
+  Ok(command_response_json(
+    "Resume finished.",
+    view.next_action,
+    Some(view.run.run_id),
+  ))
+}
+
+pub fn resolve_decisions_action(
+  repo_root: String,
+  run_id: String,
+  body: String,
+) -> Result(String, String) {
+  use config_value <- result.try(require_initialized_config(repo_root))
+  use request <- result.try(decode_body(body, decision_resolution_decoder()))
+  let answers =
+    request.answers
+    |> list.map(fn(answer) {
+      types.RecordedDecision(
+        key: answer.key,
+        question: answer.question,
+        answer: answer.answer,
+        answered_at: system.timestamp(),
+      )
+    })
+  use view <- result.try(
+    resolve_usecase.execute(
+      repo_root,
+      types.RunId(run_id),
+      None,
+      None,
+      config_value,
+      fn(_, _) { Ok(#(answers, [])) },
+    ),
+  )
+  Ok(command_response_json(
+    resolve_summary(view.summary, "Decision resolution complete."),
+    view.next_action,
+    Some(view.run.run_id),
+  ))
+}
+
+pub fn recovery_action(
+  repo_root: String,
+  run_id: String,
+  action_name: String,
+  body: String,
+) -> Result(String, String) {
+  use config_value <- result.try(require_initialized_config(repo_root))
+  use action <- result.try(parse_recovery_action(action_name))
+  let task_id =
+    decode_body(body, recovery_request_decoder())
+    |> result.unwrap(or: RecoveryRequest(task_id: None))
+    |> fn(request) { request.task_id }
+  use view <- result.try(
+    resolve_usecase.execute(
+      repo_root,
+      types.RunId(run_id),
+      task_id,
+      Some(action),
+      config_value,
+      fn(_, _) {
+        Error("Dashboard recovery actions do not collect planning decisions.")
+      },
+    ),
+  )
+  Ok(command_response_json(
+    resolve_summary(view.summary, "Recovery updated.")
+      <> "\nNext action: "
+      <> view.next_action,
+    view.next_action,
+    Some(view.run.run_id),
+  ))
+}
+
+pub fn artifact_contents(
+  repo_root: String,
+  run_id: String,
+  path_segments: List(String),
+) -> Result(#(String, String), String) {
+  use _ <- result.try(validate_artifact_segments(path_segments))
+  use #(run, _) <- result.try(journal.load(repo_root, types.RunId(run_id)))
+  let absolute_path = filepath.join(run.run_path, join_segments(path_segments))
+  use contents <- result.try(case simplifile.read(absolute_path) {
+    Ok(value) -> Ok(value)
+    Error(error) ->
+      Error(
+        "Unable to read artifact "
+        <> absolute_path
+        <> ": "
+        <> simplifile.describe_error(error),
+      )
+  })
+  Ok(#(artifact_content_type(path_segments), contents))
+}
+
+type InitRequest {
+  InitRequest(
+    provider: types.Provider,
+    model: String,
+    reasoning: Option(types.ReasoningLevel),
+    profile: Option(String),
+    generate_setup: Bool,
+  )
+}
+
+type PlanRequest {
+  PlanRequest(
+    notes: Option(String),
+    doc_path: Option(String),
+    overrides: types.AgentOverrides,
+  )
+}
+
+type DecisionAnswer {
+  DecisionAnswer(key: String, question: String, answer: String)
+}
+
+type DecisionResolutionRequest {
+  DecisionResolutionRequest(answers: List(DecisionAnswer))
+}
+
+type RecoveryRequest {
+  RecoveryRequest(task_id: Option(String))
+}
+
+fn load_repo_config(repo_root: String) -> #(types.Config, Bool) {
+  let config_path = project.config_path(repo_root)
+  case simplifile.read(config_path) {
+    Ok(contents) ->
+      case config.parse(contents) {
+        Ok(parsed) -> #(parsed, True)
+        Error(_) -> #(types.default_config(), False)
+      }
+    Error(_) -> #(types.default_config(), False)
+  }
+}
+
+fn require_initialized_config(repo_root: String) -> Result(types.Config, String) {
+  let #(loaded_config, initialized) = load_repo_config(repo_root)
+  case initialized {
+    True -> Ok(loaded_config)
+    False ->
+      Error(
+        "Night Shift is not initialized for this repository. Open `night-shift dash` and use the init flow first.",
+      )
+  }
+}
+
+fn command_response_json(
+  summary: String,
+  next_action: String,
+  run_id: Option(String),
+) -> String {
+  json.object([
+    #("ok", json.bool(True)),
+    #("summary", json.string(summary)),
+    #("next_action", json.string(next_action)),
+    #("run_id", json.nullable(from: run_id, of: json.string)),
+  ])
+  |> json.to_string
+}
+
+fn parse_recovery_action(
+  action_name: String,
+) -> Result(types.ResolveAction, String) {
+  case action_name {
+    "inspect" -> Ok(types.ResolveInspect)
+    "continue" -> Ok(types.ResolveContinue)
+    "complete" -> Ok(types.ResolveComplete)
+    "abandon" -> Ok(types.ResolveAbandon)
+    _ -> Error("Unsupported dashboard recovery action: " <> action_name)
+  }
+}
+
+fn validate_artifact_segments(
+  path_segments: List(String),
+) -> Result(Nil, String) {
+  case
+    list.any(path_segments, fn(segment) {
+      segment == "" || segment == "." || segment == ".."
+    })
+  {
+    True -> Error("Invalid artifact path.")
+    False -> Ok(Nil)
+  }
+}
+
+fn join_segments(segments: List(String)) -> String {
+  case segments {
+    [] -> ""
+    [segment] -> segment
+    [segment, ..rest] -> filepath.join(segment, join_segments(rest))
+  }
+}
+
+fn artifact_content_type(path_segments: List(String)) -> String {
+  case reverse(path_segments, []) {
+    ["json", ..] -> "application/json; charset=utf-8"
+    ["md", ..] -> "text/markdown; charset=utf-8"
+    ["log", ..] -> "text/plain; charset=utf-8"
+    _ -> "text/plain; charset=utf-8"
+  }
+}
+
+fn reverse(items: List(String), acc: List(String)) -> List(String) {
+  case items {
+    [] -> acc
+    [item, ..rest] -> reverse(rest, [item, ..acc])
+  }
+}
+
+fn resolve_summary(summary: Option(String), fallback: String) -> String {
+  case summary {
+    Some(value) -> value
+    None -> fallback
+  }
+}
+
+fn decode_body(body: String, decoder: decode.Decoder(a)) -> Result(a, String) {
+  json.parse(body, decoder)
+  |> result.map_error(fn(_) { "Invalid dashboard request body." })
+}
+
+fn init_request_decoder() -> decode.Decoder(InitRequest) {
+  use raw_provider <- decode.field("provider", decode.string)
+  use model <- decode.field("model", decode.string)
+  use maybe_reasoning <- decode.optional_field(
+    "reasoning",
+    None,
+    decode.optional(decode.string),
+  )
+  use profile <- decode.optional_field(
+    "profile",
+    None,
+    decode.optional(decode.string),
+  )
+  use generate_setup <- decode.optional_field(
+    "generate_setup",
+    False,
+    decode.bool,
+  )
+  case types.provider_from_string(raw_provider) {
+    Ok(provider) ->
+      decode.success(InitRequest(
+        provider: provider,
+        model: model,
+        reasoning: parse_reasoning(maybe_reasoning),
+        profile: profile,
+        generate_setup: generate_setup,
+      ))
+    Error(_) ->
+      decode.failure(
+        InitRequest(
+          provider: types.Codex,
+          model: "",
+          reasoning: None,
+          profile: None,
+          generate_setup: False,
+        ),
+        "InitRequest",
+      )
+  }
+}
+
+fn plan_request_decoder() -> decode.Decoder(PlanRequest) {
+  use notes <- decode.optional_field(
+    "notes",
+    None,
+    decode.optional(decode.string),
+  )
+  use doc_path <- decode.optional_field(
+    "doc_path",
+    None,
+    decode.optional(decode.string),
+  )
+  use profile <- decode.optional_field(
+    "profile",
+    None,
+    decode.optional(decode.string),
+  )
+  use raw_provider <- decode.optional_field(
+    "provider",
+    None,
+    decode.optional(decode.string),
+  )
+  use model <- decode.optional_field(
+    "model",
+    None,
+    decode.optional(decode.string),
+  )
+  use maybe_reasoning <- decode.optional_field(
+    "reasoning",
+    None,
+    decode.optional(decode.string),
+  )
+  decode.success(PlanRequest(
+    notes: notes,
+    doc_path: doc_path,
+    overrides: types.AgentOverrides(
+      profile: profile,
+      provider: parse_provider(raw_provider),
+      model: model,
+      reasoning: parse_reasoning(maybe_reasoning),
+    ),
+  ))
+}
+
+fn decision_resolution_decoder() -> decode.Decoder(DecisionResolutionRequest) {
+  use answers <- decode.field("answers", decode.list(decision_answer_decoder()))
+  decode.success(DecisionResolutionRequest(answers: answers))
+}
+
+fn decision_answer_decoder() -> decode.Decoder(DecisionAnswer) {
+  use key <- decode.field("key", decode.string)
+  use question <- decode.field("question", decode.string)
+  use answer <- decode.field("answer", decode.string)
+  decode.success(DecisionAnswer(key: key, question: question, answer: answer))
+}
+
+fn recovery_request_decoder() -> decode.Decoder(RecoveryRequest) {
+  use task_id <- decode.optional_field(
+    "task_id",
+    None,
+    decode.optional(decode.string),
+  )
+  decode.success(RecoveryRequest(task_id: task_id))
+}
+
+fn parse_reasoning(
+  maybe_reasoning: Option(String),
+) -> Option(types.ReasoningLevel) {
+  case maybe_reasoning {
+    Some(raw_reasoning) ->
+      case types.reasoning_from_string(raw_reasoning) {
+        Ok(level) -> Some(level)
+        Error(_) -> None
+      }
+    None -> None
+  }
+}
+
+fn parse_provider(maybe_provider: Option(String)) -> Option(types.Provider) {
+  case maybe_provider {
+    Some(raw_provider) ->
+      case types.provider_from_string(raw_provider) {
+        Ok(provider) -> Some(provider)
+        Error(_) -> None
+      }
+    None -> None
+  }
+}
diff --git a/src/night_shift/dash/assets.gleam b/src/night_shift/dash/assets.gleam
new file mode 100644
index 0000000..6719f44
--- /dev/null
+++ b/src/night_shift/dash/assets.gleam
@@ -0,0 +1,196 @@
+import filepath
+import gleam/result
+import gleam/string
+import night_shift/shell
+import night_shift/system
+import simplifile
+
+pub const js_asset = "dash.js"
+
+pub const css_asset = "dash.css"
+
+pub fn asset_root() -> String {
+  case system.get_env("NIGHT_SHIFT_DASH_ASSET_ROOT") {
+    "" -> filepath.join(system.cwd(), "build/dash-assets")
+    root -> root
+  }
+}
+
+pub fn ensure_assets_ready() -> Result(String, String) {
+  let root = asset_root()
+  case assets_present(root) {
+    True -> Ok(root)
+    False -> build_assets(root)
+  }
+}
+
+pub fn read_asset(path_segments: List(String)) -> Result(String, String) {
+  use root <- result.try(ensure_assets_ready())
+  use relative_path <- result.try(validate_relative_path(path_segments))
+  let target_path = filepath.join(root, relative_path)
+  case simplifile.read(target_path) {
+    Ok(contents) -> Ok(contents)
+    Error(error) ->
+      Error(
+        "Unable to read dashboard asset "
+        <> target_path
+        <> ": "
+        <> simplifile.describe_error(error),
+      )
+  }
+}
+
+pub fn content_type(path_segments: List(String)) -> String {
+  case list_reverse(path_segments) {
+    [filename, ..] ->
+      case
+        string.ends_with(filename, ".css"),
+        string.ends_with(filename, ".mjs") || string.ends_with(filename, ".js"),
+        string.ends_with(filename, ".json")
+      {
+        True, _, _ -> "text/css; charset=utf-8"
+        _, True, _ -> "text/javascript; charset=utf-8"
+        _, _, True -> "application/json; charset=utf-8"
+        _, _, _ -> "text/plain; charset=utf-8"
+      }
+    [] -> "text/plain; charset=utf-8"
+  }
+}
+
+pub fn app_shell(initial_run_id: String) -> Result(String, String) {
+  use _ <- result.try(ensure_assets_ready())
+  Ok(
+    "<!doctype html>\n"
+    <> "<html lang=\"en\">\n"
+    <> "<head>\n"
+    <> "  <meta charset=\"utf-8\">\n"
+    <> "  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"
+    <> "  <title>Night Shift Dashboard</title>\n"
+    <> "  <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\">\n"
+    <> "  <link rel=\"preconnect\" href=\"https://fonts.gstatic.com\" crossorigin>\n"
+    <> "  <link href=\"https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;1,6..72,400;1,6..72,500&family=Outfit:wght@300;400;500;600&family=JetBrains+Mono:wght@400;500&display=swap\" rel=\"stylesheet\">\n"
+    <> "  <style>body{background:#0c0c0f;color:#e2ddd5}</style>\n"
+    <> "  <link rel=\"stylesheet\" href=\"/assets/dash.css\">\n"
+    <> "</head>\n"
+    <> "<body>\n"
+    <> "  <div class=\"accent-bar\" aria-hidden=\"true\"></div>\n"
+    <> "  <div id=\"app\" data-initial-run=\""
+    <> escape_attribute(initial_run_id)
+    <> "\"></div>\n"
+    <> "  <script type=\"module\" src=\"/assets/dash.js\"></script>\n"
+    <> "</body>\n"
+    <> "</html>\n",
+  )
+}
+
+fn build_assets(root: String) -> Result(String, String) {
+  let script_path = filepath.join(system.cwd(), "scripts/build_dash_assets.sh")
+  case simplifile.read(script_path) {
+    Ok(_) -> {
+      use _ <- result.try(ensure_directory(log_directory()))
+      let log_path = filepath.join(log_directory(), "dash-assets-build.log")
+      let command = "sh " <> shell.quote(script_path)
+      let outcome = shell.run(command, system.cwd(), log_path)
+      case shell.succeeded(outcome) && assets_present(root) {
+        True -> Ok(root)
+        False ->
+          Error(
+            "Night Shift could not prepare dashboard assets. See " <> log_path,
+          )
+      }
+    }
+    Error(_) ->
+      Error(
+        "Night Shift dashboard assets are unavailable. Install a Night Shift CLI bundle that includes assets or build them with scripts/build_dash_assets.sh.",
+      )
+  }
+}
+
+fn assets_present(root: String) -> Bool {
+  file_exists(filepath.join(root, js_asset))
+  && file_exists(filepath.join(root, css_asset))
+}
+
+fn file_exists(path: String) -> Bool {
+  case simplifile.read(path) {
+    Ok(_) -> True
+    Error(_) -> False
+  }
+}
+
+fn validate_relative_path(path_segments: List(String)) -> Result(String, String) {
+  case
+    list_any(path_segments, fn(segment) {
+      segment == ".." || segment == "." || segment == ""
+    })
+  {
+    True -> Error("Invalid dashboard asset path.")
+    False -> Ok(path_segments |> join_segments)
+  }
+}
+
+fn join_segments(segments: List(String)) -> String {
+  case segments {
+    [] -> ""
+    [segment] -> segment
+    [segment, ..rest] -> filepath.join(segment, join_segments(rest))
+  }
+}
+
+fn ensure_directory(path: String) -> Result(Nil, String) {
+  case simplifile.create_directory_all(path) {
+    Ok(Nil) -> Ok(Nil)
+    Error(error) ->
+      Error(
+        "Unable to prepare dashboard asset directory "
+        <> path
+        <> ": "
+        <> simplifile.describe_error(error),
+      )
+  }
+}
+
+fn log_directory() -> String {
+  filepath.join(system.state_directory(), "night-shift")
+}
+
+fn escape_attribute(value: String) -> String {
+  value
+  |> string_replace("&", "&amp;")
+  |> string_replace("\"", "&quot;")
+  |> string_replace("<", "&lt;")
+  |> string_replace(">", "&gt;")
+}
+
+fn string_replace(
+  value: String,
+  each target: String,
+  with replacement: String,
+) -> String {
+  case target {
+    "" -> value
+    _ -> string.replace(in: value, each: target, with: replacement)
+  }
+}
+
+fn list_reverse(items: List(String)) -> List(String) {
+  reverse(items, [])
+}
+
+fn reverse(items: List(String), acc: List(String)) -> List(String) {
+  case items {
+    [] -> acc
+    [item, ..rest] -> reverse(rest, [item, ..acc])
+  }
+}
+
+fn list_any(items: List(a), predicate: fn(a) -> Bool) -> Bool {
+  case items {
+    [] -> False
+    [item, ..rest] ->
+      case predicate(item) {
+        True -> True
+        False -> list_any(rest, predicate)
+      }
+  }
+}
diff --git a/src/night_shift/dash/projection.gleam b/src/night_shift/dash/projection.gleam
new file mode 100644
index 0000000..ed9ad16
--- /dev/null
+++ b/src/night_shift/dash/projection.gleam
@@ -0,0 +1,649 @@
+import filepath
+import gleam/json
+import gleam/list
+import gleam/option.{type Option, None, Some}
+import gleam/result
+import gleam/string
+import night_shift/dash/session
+import night_shift/domain/confidence
+import night_shift/domain/decisions as decision_domain
+import night_shift/domain/provenance as provenance_domain
+import night_shift/domain/repo_state
+import night_shift/domain/review_run_projection
+import night_shift/domain/summary as domain_summary
+import night_shift/journal
+import night_shift/repo_state_runtime
+import night_shift/report
+import night_shift/types
+import night_shift/usecase/support/runs
+import simplifile
+
+pub fn workspace_json(
+  repo_root: String,
+  requested_run_id: Option(String),
+  config: types.Config,
+  initialized: Bool,
+  command_state: Option(session.CommandState),
+) -> Result(String, String) {
+  use runs <- result.try(journal.list_runs(repo_root))
+  let selected_run_id = choose_selected_run_id(runs, requested_run_id)
+  let selected_run = case selected_run_id {
+    Some(run_id) -> load_run_projection(repo_root, run_id, config)
+    None -> Ok(None)
+  }
+
+  use run_projection <- result.try(selected_run)
+
+  Ok(
+    json.object([
+      #("repo_root", json.string(repo_root)),
+      #("initialized", json.bool(initialized)),
+      #("config_present", json.bool(initialized)),
+      #(
+        "worktree_setup_present",
+        json.bool(
+          file_exists(filepath.join(
+            repo_root,
+            ".night-shift/worktree-setup.toml",
+          )),
+        ),
+      ),
+      #("default_profile", json.string(config.default_profile)),
+      #("providers", json.array(provider_names(), json.string)),
+      #(
+        "selected_run_id",
+        json.nullable(from: selected_run_id, of: json.string),
+      ),
+      #("runs", json.array(runs, run_summary_json)),
+      #(
+        "command_state",
+        json.nullable(from: command_state, of: command_state_json),
+      ),
+      #("run", json.nullable(from: run_projection, of: identity_json)),
+    ])
+    |> json.to_string,
+  )
+}
+
+pub fn load_run_projection(
+  repo_root: String,
+  run_id: String,
+  config: types.Config,
+) -> Result(Option(json.Json), String) {
+  journal.load(repo_root, types.RunId(run_id))
+  |> result.map(fn(run_and_events) {
+    let #(run, events) = run_and_events
+    Some(run_projection_json(run, events, config))
+  })
+}
+
+fn run_projection_json(
+  run: types.RunRecord,
+  events: List(types.RunEvent),
+  config: types.Config,
+) -> json.Json {
+  let inspection = repo_state_runtime.inspect(run, config.branch_prefix)
+  let repo_state_view = inspection.view
+  let review_projection =
+    review_run_projection.build(run, events, repo_state_view)
+  let confidence_assessment = confidence.assess(run, events, repo_state_view)
+  let report_markdown = report.render_live(run, events, repo_state_view)
+  let provenance_markdown =
+    provenance_domain.render(
+      run,
+      events,
+      repo_state_view,
+      None,
+      types.ProvenanceMarkdown,
+      config.verification_commands,
+    )
+    |> result.unwrap(or: "Unable to render provenance.")
+  let decision_prompts =
+    decision_domain.pending_decision_prompts(run.decisions, run.tasks)
+  let recovery_intro = domain_summary.setup_recovery_intro(run)
+  let recovery_outcome_lines = domain_summary.setup_recovery_outcome_lines(run)
+
+  json.object([
+    #("run_id", json.string(run.run_id)),
+    #("status", json.string(types.run_status_to_string(run.status))),
+    #("created_at", json.string(run.created_at)),
+    #("updated_at", json.string(run.updated_at)),
+    #("brief_path", json.string(run.brief_path)),
+    #("report_path", json.string(run.report_path)),
+    #("provenance_path", json.string(provenance_domain.artifact_path(run))),
+    #("next_action", json.string(runs.next_action_for_run(run))),
+    #(
+      "planning_provenance",
+      json.nullable(from: run.planning_provenance, of: planning_provenance_json),
+    ),
+    #(
+      "notes_source",
+      json.nullable(from: run.notes_source, of: notes_source_json),
+    ),
+    #("planning_agent", agent_json(run.planning_agent)),
+    #("execution_agent", agent_json(run.execution_agent)),
+    #(
+      "confidence",
+      json.object([
+        #(
+          "level",
+          json.string(types.confidence_posture_to_string(
+            confidence_assessment.posture,
+          )),
+        ),
+        #("reasons", json.array(confidence_assessment.reasons, json.string)),
+      ]),
+    ),
+    #(
+      "confidence_posture",
+      json.string(types.confidence_posture_to_string(
+        confidence_assessment.posture,
+      )),
+    ),
+    #(
+      "confidence_reasons",
+      json.array(confidence_assessment.reasons, json.string),
+    ),
+    #("dag", dag_json(run.tasks, events)),
+    #("tasks", json.array(run.tasks, task_json(_, events, run))),
+    #("decisions", json.array(decision_prompts, pending_decision_json)),
+    #(
+      "repo_state",
+      json.nullable(from: review_projection, of: review_projection_json),
+    ),
+    #("timeline", json.array(events, event_json)),
+    #("events", json.array(events, event_json)),
+    #("report_markdown", json.string(report_markdown)),
+    #("report", json.string(report_markdown)),
+    #("provenance_markdown", json.string(provenance_markdown)),
+    #(
+      "artifacts",
+      json.object([
+        #("report_url", json.string(artifact_url(run.run_id, ["report.md"]))),
+        #(
+          "provenance_url",
+          json.string(artifact_url(run.run_id, ["provenance.json"])),
+        ),
+      ]),
+    ),
+    #("delivery", json.array(delivery_rows(run.tasks, events), delivery_json)),
+    #(
+      "replacement_pr_numbers",
+      json.array(replacement_pr_numbers(run.tasks), json.int),
+    ),
+    #("recovery_intro", json.string(recovery_intro)),
+    #("recovery_outcome_lines", json.array(recovery_outcome_lines, json.string)),
+    #(
+      "recovery_blocker",
+      json.nullable(from: run.recovery_blocker, of: recovery_blocker_json),
+    ),
+    #(
+      "recovery",
+      json.object([
+        #(
+          "setup_blocker",
+          json.nullable(from: run.recovery_blocker, of: recovery_blocker_json),
+        ),
+        #(
+          "implementation_blockers",
+          json.array(
+            decision_domain.implementation_blocking_tasks(run),
+            task_json(_, events, run),
+          ),
+        ),
+      ]),
+    ),
+  ])
+}
+
+fn run_summary_json(run: types.RunRecord) -> json.Json {
+  json.object([
+    #("run_id", json.string(run.run_id)),
+    #("status", json.string(types.run_status_to_string(run.status))),
+    #("created_at", json.string(run.created_at)),
+    #("updated_at", json.string(run.updated_at)),
+    #("task_count", json.int(list.length(run.tasks))),
+    #("planning_dirty", json.bool(run.planning_dirty)),
+  ])
+}
+
+fn agent_json(agent: types.ResolvedAgentConfig) -> json.Json {
+  json.object([
+    #("profile_name", json.string(agent.profile_name)),
+    #("provider", json.string(types.provider_to_string(agent.provider))),
+    #("model", json.nullable(from: agent.model, of: json.string)),
+    #(
+      "reasoning",
+      json.nullable(from: agent.reasoning, of: fn(reasoning) {
+        json.string(types.reasoning_to_string(reasoning))
+      }),
+    ),
+  ])
+}
+
+fn planning_provenance_json(provenance: types.PlanningProvenance) -> json.Json {
+  json.object([
+    #("label", json.string(types.planning_provenance_label(provenance))),
+    #(
+      "uses_reviews",
+      json.bool(types.planning_provenance_uses_reviews(provenance)),
+    ),
+    #(
+      "notes_source",
+      json.nullable(
+        from: types.planning_provenance_notes_source(provenance),
+        of: notes_source_json,
+      ),
+    ),
+  ])
+}
+
+fn notes_source_json(source: types.NotesSource) -> json.Json {
+  json.object([
+    #("label", json.string(types.notes_source_label(source))),
+    #(
+      "kind",
+      json.string(case source {
+        types.NotesFile(_) -> "file"
+        types.InlineNotes(_) -> "inline"
+      }),
+    ),
+    #(
+      "path",
+      json.string(case source {
+        types.NotesFile(path) | types.InlineNotes(path) -> path
+      }),
+    ),
+  ])
+}
+
+fn dag_json(tasks: List(types.Task), events: List(types.RunEvent)) -> json.Json {
+  json.object([
+    #("nodes", json.array(tasks, dag_node_json(_, events))),
+    #("edges", json.array(tasks |> dag_edges, dag_edge_json)),
+  ])
+}
+
+fn dag_node_json(task: types.Task, events: List(types.RunEvent)) -> json.Json {
+  json.object([
+    #("id", json.string(task.id)),
+    #("title", json.string(task.title)),
+    #("state", json.string(types.task_state_to_string(task.state))),
+    #("kind", json.string(types.task_kind_to_string(task.kind))),
+    #("branch_name", json.string(task.branch_name)),
+    #("pr_number", json.string(task.pr_number)),
+    #(
+      "pr_url",
+      json.nullable(from: task_pr_url(events, task.id), of: json.string),
+    ),
+  ])
+}
+
+fn dag_edges(tasks: List(types.Task)) -> List(#(String, String)) {
+  tasks
+  |> list.map(fn(task) {
+    task.dependencies |> list.map(fn(dep) { #(dep, task.id) })
+  })
+  |> list.flatten
+}
+
+fn dag_edge_json(edge: #(String, String)) -> json.Json {
+  json.object([
+    #("from", json.string(edge.0)),
+    #("to", json.string(edge.1)),
+  ])
+}
+
+fn task_json(
+  task: types.Task,
+  events: List(types.RunEvent),
+  run: types.RunRecord,
+) -> json.Json {
+  json.object([
+    #("id", json.string(task.id)),
+    #("title", json.string(task.title)),
+    #("description", json.string(task.description)),
+    #("summary", json.string(task.summary)),
+    #("state", json.string(types.task_state_to_string(task.state))),
+    #("kind", json.string(types.task_kind_to_string(task.kind))),
+    #(
+      "execution_mode",
+      json.string(types.execution_mode_to_string(task.execution_mode)),
+    ),
+    #("dependencies", json.array(task.dependencies, json.string)),
+    #("acceptance", json.array(task.acceptance, json.string)),
+    #("demo_plan", json.array(task.demo_plan, json.string)),
+    #("branch_name", json.string(task.branch_name)),
+    #("pr_number", json.string(task.pr_number)),
+    #(
+      "pr_url",
+      json.nullable(from: task_pr_url(events, task.id), of: json.string),
+    ),
+    #("superseded_pr_numbers", json.array(task.superseded_pr_numbers, json.int)),
+    #("worktree_path", json.string(task.worktree_path)),
+    #(
+      "runtime_context",
+      json.nullable(from: task.runtime_context, of: runtime_context_json),
+    ),
+    #(
+      "decision_requests",
+      json.array(task.decision_requests, decision_request_json),
+    ),
+    #(
+      "artifacts",
+      json.object([
+        #(
+          "task_log_url",
+          json.string(artifact_url(run.run_id, ["logs", task.id <> ".log"])),
+        ),
+        #(
+          "verify_log_url",
+          json.string(
+            artifact_url(run.run_id, ["logs", task.id <> ".verify.log"]),
+          ),
+        ),
+      ]),
+    ),
+  ])
+}
+
+fn runtime_context_json(context: types.RuntimeContext) -> json.Json {
+  json.object([
+    #("worktree_id", json.string(context.worktree_id)),
+    #("compose_project", json.string(context.compose_project)),
+    #("port_base", json.int(context.port_base)),
+    #("runtime_dir", json.string(context.runtime_dir)),
+    #("env_file_path", json.string(context.env_file_path)),
+    #("manifest_path", json.string(context.manifest_path)),
+    #("handoff_path", json.string(context.handoff_path)),
+    #("named_ports", json.array(context.named_ports, runtime_port_json)),
+  ])
+}
+
+fn runtime_port_json(port: types.RuntimePort) -> json.Json {
+  json.object([
+    #("name", json.string(port.name)),
+    #("value", json.int(port.value)),
+  ])
+}
+
+fn decision_request_json(request: types.DecisionRequest) -> json.Json {
+  json.object([
+    #("key", json.string(request.key)),
+    #("question", json.string(request.question)),
+    #("rationale", json.string(request.rationale)),
+    #("allow_freeform", json.bool(request.allow_freeform)),
+    #(
+      "recommended_option",
+      json.nullable(from: request.recommended_option, of: json.string),
+    ),
+    #("options", json.array(request.options, decision_option_json)),
+  ])
+}
+
+fn decision_option_json(option: types.DecisionOption) -> json.Json {
+  json.object([
+    #("label", json.string(option.label)),
+    #("description", json.string(option.description)),
+  ])
+}
+
+fn pending_decision_json(
+  prompt: #(types.Task, types.DecisionRequest),
+) -> json.Json {
+  json.object([
+    #("task_id", json.string(prompt.0.id)),
+    #("task_title", json.string(prompt.0.title)),
+    #("request", decision_request_json(prompt.1)),
+  ])
+}
+
+fn review_projection_json(
+  projection: review_run_projection.ReviewRunProjection,
+) -> json.Json {
+  json.object([
+    #(
+      "repo_state",
+      json.object([
+        #(
+          "captured_open_pr_count",
+          json.int(projection.repo_state.captured_open_pr_count),
+        ),
+        #(
+          "captured_actionable_pr_count",
+          json.int(projection.repo_state.captured_actionable_pr_count),
+        ),
+        #(
+          "snapshot_captured_at",
+          json.string(projection.repo_state.snapshot_captured_at),
+        ),
+        #(
+          "current_open_pr_count",
+          json.nullable(
+            from: projection.repo_state.current_open_pr_count,
+            of: json.int,
+          ),
+        ),
+        #(
+          "current_actionable_pr_count",
+          json.nullable(
+            from: projection.repo_state.current_actionable_pr_count,
+            of: json.int,
+          ),
+        ),
+        #(
+          "drift",
+          json.nullable(from: projection.repo_state.drift, of: json.string),
+        ),
+        #(
+          "drift_details",
+          json.nullable(
+            from: projection.repo_state.drift_details,
+            of: json.string,
+          ),
+        ),
+        #(
+          "actionable_pull_requests",
+          json.array(
+            projection.repo_state.actionable_pull_requests,
+            pull_request_json,
+          ),
+        ),
+        #(
+          "impacted_pull_requests",
+          json.array(
+            projection.repo_state.impacted_pull_requests,
+            pull_request_json,
+          ),
+        ),
+      ]),
+    ),
+    #(
+      "replacement_lineage",
+      json.array(projection.lineage_entries, lineage_entry_json),
+    ),
+    #(
+      "supersession_outcomes",
+      json.array(projection.supersession_outcomes, json.string),
+    ),
+    #(
+      "supersession_warnings",
+      json.array(projection.supersession_warnings, json.string),
+    ),
+  ])
+}
+
+fn pull_request_json(pr: repo_state.RepoPullRequestSnapshot) -> json.Json {
+  json.object([
+    #("number", json.int(pr.number)),
+    #("title", json.string(pr.title)),
+    #("branch_name", json.string(pr.head_ref_name)),
+    #("url", json.string(pr.url)),
+    #("actionable", json.bool(pr.actionable)),
+    #("impacted", json.bool(pr.impacted)),
+  ])
+}
+
+fn lineage_entry_json(
+  entry: review_run_projection.ReplacementLineageEntry,
+) -> json.Json {
+  json.object([
+    #("task_id", json.string(entry.task_id)),
+    #(
+      "superseded_pr_numbers",
+      json.array(entry.superseded_pr_numbers, json.int),
+    ),
+    #(
+      "replacement_pr_number",
+      json.nullable(from: entry.replacement_pr_number, of: json.string),
+    ),
+  ])
+}
+
+fn event_json(event: types.RunEvent) -> json.Json {
+  json.object([
+    #("kind", json.string(event.kind)),
+    #("at", json.string(event.at)),
+    #("message", json.string(event.message)),
+    #("task_id", json.nullable(from: event.task_id, of: json.string)),
+  ])
+}
+
+fn delivery_rows(
+  tasks: List(types.Task),
+  events: List(types.RunEvent),
+) -> List(#(types.Task, String)) {
+  tasks
+  |> list.filter_map(fn(task) {
+    case task.pr_number, task_pr_url(events, task.id) {
+      "", _ -> Error(Nil)
+      _, None -> Error(Nil)
+      _, Some(pr_url) -> Ok(#(task, pr_url))
+    }
+  })
+}
+
+fn delivery_json(row: #(types.Task, String)) -> json.Json {
+  json.object([
+    #("task_id", json.string(row.0.id)),
+    #("task_title", json.string(row.0.title)),
+    #("pr_number", json.string(row.0.pr_number)),
+    #("pr_url", json.string(row.1)),
+  ])
+}
+
+fn replacement_pr_numbers(tasks: List(types.Task)) -> List(Int) {
+  unique_pr_numbers(
+    tasks |> list.flat_map(fn(task) { task.superseded_pr_numbers }),
+    [],
+  )
+}
+
+fn unique_pr_numbers(values: List(Int), acc: List(Int)) -> List(Int) {
+  case values {
+    [] -> list.reverse(acc)
+    [value, ..rest] ->
+      case list.contains(acc, value) {
+        True -> unique_pr_numbers(rest, acc)
+        False -> unique_pr_numbers(rest, [value, ..acc])
+      }
+  }
+}
+
+fn recovery_blocker_json(blocker: types.RecoveryBlocker) -> json.Json {
+  json.object([
+    #(
+      "kind",
+      json.string(case blocker.kind {
+        types.EnvironmentPreflightBlocker -> "environment_preflight"
+        types.TaskSetupBlocker -> "task_setup"
+      }),
+    ),
+    #(
+      "phase",
+      json.string(case blocker.phase {
+        types.PreflightPhase -> "preflight"
+        types.SetupPhase -> "setup"
+        types.MaintenancePhase -> "maintenance"
+      }),
+    ),
+    #("task_id", json.nullable(from: blocker.task_id, of: json.string)),
+    #("message", json.string(blocker.message)),
+    #("log_path", json.string(blocker.log_path)),
+    #("no_changes_produced", json.bool(blocker.no_changes_produced)),
+    #(
+      "disposition",
+      json.string(case blocker.disposition {
+        types.RecoveryBlocking -> "blocking"
+        types.RecoveryWaivedOnce -> "waived_once"
+      }),
+    ),
+  ])
+}
+
+fn command_state_json(state: session.CommandState) -> json.Json {
+  json.object([
+    #("name", json.string(state.name)),
+    #("run_id", json.nullable(from: state.run_id, of: json.string)),
+    #("started_at", json.string(state.started_at)),
+    #("summary", json.string(state.summary)),
+  ])
+}
+
+fn choose_selected_run_id(
+  runs: List(types.RunRecord),
+  requested_run_id: Option(String),
+) -> Option(String) {
+  case requested_run_id {
+    Some(run_id) ->
+      case list.any(runs, fn(run) { run.run_id == run_id }) {
+        True -> Some(run_id)
+        False -> fallback_run_id(runs)
+      }
+    None -> fallback_run_id(runs)
+  }
+}
+
+fn fallback_run_id(runs: List(types.RunRecord)) -> Option(String) {
+  case runs {
+    [run, ..] -> Some(run.run_id)
+    [] -> None
+  }
+}
+
+fn provider_names() -> List(String) {
+  ["codex", "cursor"]
+}
+
+fn task_pr_url(events: List(types.RunEvent), task_id: String) -> Option(String) {
+  find_task_pr_url(list.reverse(events), task_id)
+}
+
+fn artifact_url(run_id: String, path_segments: List(String)) -> String {
+  "/artifacts/runs/" <> run_id <> "/" <> string.join(path_segments, with: "/")
+}
+
+fn file_exists(path: String) -> Bool {
+  case simplifile.read(path) {
+    Ok(_) -> True
+    Error(_) -> False
+  }
+}
+
+fn find_task_pr_url(
+  events: List(types.RunEvent),
+  task_id: String,
+) -> Option(String) {
+  case events {
+    [] -> None
+    [event, ..rest] ->
+      case event.kind == "pr_opened" && event.task_id == Some(task_id) {
+        True -> Some(event.message)
+        False -> find_task_pr_url(rest, task_id)
+      }
+  }
+}
+
+fn identity_json(value: json.Json) -> json.Json {
+  value
+}
diff --git a/src/night_shift/dash/session.gleam b/src/night_shift/dash/session.gleam
new file mode 100644
index 0000000..a467aee
--- /dev/null
+++ b/src/night_shift/dash/session.gleam
@@ -0,0 +1,80 @@
+import gleam/io
+import gleam/option.{type Option}
+import gleam/result
+import night_shift/dash/assets
+import night_shift/journal
+import night_shift/system
+import night_shift/types
+
+pub type Session {
+  Session(url: String, handle: String)
+}
+
+pub type CommandState {
+  CommandState(
+    name: String,
+    run_id: Option(String),
+    started_at: String,
+    summary: String,
+  )
+}
+
+@external(erlang, "night_shift_dashboard_server", "start_session")
+fn start_session_raw(
+  repo_root: String,
+  initial_run_id: String,
+) -> Result(Session, String)
+
+@external(erlang, "night_shift_dashboard_server", "stop_session")
+pub fn stop_session(session: Session) -> Nil
+
+@external(erlang, "night_shift_dashboard_server", "command_state")
+pub fn command_state(repo_root: String) -> Option(CommandState)
+
+pub fn open(
+  repo_root: String,
+  initial_run_id: String,
+) -> Result(Session, String) {
+  start_session_raw(repo_root, initial_run_id)
+}
+
+pub fn view(
+  repo_root: String,
+  selector: types.RunSelector,
+) -> Result(Nil, String) {
+  use _ <- result.try(assets.ensure_assets_ready())
+  use initial_run_id <- result.try(resolve_initial_run_id(repo_root, selector))
+  use session <- result.try(open(repo_root, initial_run_id))
+  io.println(render_dashboard_summary(session.url, initial_run_id))
+  system.wait_forever()
+  Ok(Nil)
+}
+
+fn render_dashboard_summary(url: String, run_id: String) -> String {
+  "Dashboard: "
+  <> url
+  <> "\nRun: "
+  <> case run_id {
+    "" -> "(auto)"
+    value -> value
+  }
+}
+
+fn resolve_initial_run_id(
+  repo_root: String,
+  selector: types.RunSelector,
+) -> Result(String, String) {
+  case selector {
+    types.RunId(run_id) -> {
+      use _ <- result.try(journal.load(repo_root, selector))
+      Ok(run_id)
+    }
+    types.LatestRun -> {
+      use run_list <- result.try(journal.list_runs(repo_root))
+      Ok(case run_list {
+        [run, ..] -> run.run_id
+        [] -> ""
+      })
+    }
+  }
+}
diff --git a/src/night_shift/dash/stream.gleam b/src/night_shift/dash/stream.gleam
new file mode 100644
index 0000000..e80e1c5
--- /dev/null
+++ b/src/night_shift/dash/stream.gleam
@@ -0,0 +1,230 @@
+import gleam/json
+import gleam/list
+import gleam/option.{type Option, None, Some}
+import gleam/result
+import gleam/string
+import night_shift/dash/session
+import night_shift/journal
+import night_shift/system
+import night_shift/types
+
+pub type Snapshot {
+  Snapshot(
+    run_id: String,
+    run_updated_at: String,
+    status: String,
+    event_count: Int,
+    task_signature: String,
+    delivery_signature: String,
+    repo_state_signature: String,
+    command_signature: String,
+  )
+}
+
+pub fn snapshot(
+  repo_root: String,
+  requested_run_id: Option(String),
+) -> Result(Option(Snapshot), String) {
+  use runs <- result.try(journal.list_runs(repo_root))
+  let selected_run_id = choose_selected_run_id(runs, requested_run_id)
+  case selected_run_id {
+    None -> Ok(None)
+    Some(run_id) -> {
+      use #(run, events) <- result.try(journal.load(
+        repo_root,
+        types.RunId(run_id),
+      ))
+      Ok(
+        Some(Snapshot(
+          run_id: run.run_id,
+          run_updated_at: run.updated_at,
+          status: types.run_status_to_string(run.status),
+          event_count: list.length(events),
+          task_signature: task_signature(run.tasks),
+          delivery_signature: delivery_signature(events),
+          repo_state_signature: repo_state_signature(run),
+          command_signature: command_signature(session.command_state(repo_root)),
+        )),
+      )
+    }
+  }
+}
+
+pub fn diff_events(
+  previous: Option(Snapshot),
+  current: Option(Snapshot),
+) -> List(json.Json) {
+  case previous, current {
+    None, None -> [keepalive_event("")]
+    None, Some(now) -> [
+      event("workspace_updated", now.run_id),
+      event("run_updated", now.run_id),
+      event("dag_updated", now.run_id),
+      event("timeline_appended", now.run_id),
+    ]
+    Some(_), None -> [keepalive_event("")]
+    Some(before), Some(after) ->
+      compact_events([
+        maybe_event(
+          before.command_signature != after.command_signature,
+          after.run_id,
+          case before.command_signature, after.command_signature {
+            "", _ -> "command_started"
+            _, "" -> "command_finished"
+            _, _ -> "command_finished"
+          },
+        ),
+        maybe_event(
+          before.run_updated_at != after.run_updated_at
+            || before.status != after.status,
+          after.run_id,
+          "run_updated",
+        ),
+        maybe_event(
+          before.task_signature != after.task_signature,
+          after.run_id,
+          "dag_updated",
+        ),
+        maybe_event(
+          before.event_count != after.event_count,
+          after.run_id,
+          "timeline_appended",
+        ),
+        maybe_event(
+          before.delivery_signature != after.delivery_signature,
+          after.run_id,
+          "delivery_updated",
+        ),
+        maybe_event(
+          before.repo_state_signature != after.repo_state_signature,
+          after.run_id,
+          "repo_state_updated",
+        ),
+      ])
+      |> ensure_workspace_event(after.run_id)
+  }
+}
+
+pub fn keepalive_json(run_id: String) -> String {
+  keepalive_event(run_id) |> json.to_string
+}
+
+pub fn event_json(event_payload: json.Json) -> String {
+  json.to_string(event_payload)
+}
+
+fn event(kind: String, run_id: String) -> json.Json {
+  json.object([
+    #("id", json.string(system.unique_id())),
+    #("kind", json.string(kind)),
+    #("run_id", json.string(run_id)),
+    #("at", json.string(system.timestamp())),
+    #("payload", json.object([])),
+  ])
+}
+
+fn keepalive_event(run_id: String) -> json.Json {
+  json.object([
+    #("id", json.string(system.unique_id())),
+    #("kind", json.string("stream_keepalive")),
+    #("run_id", json.string(run_id)),
+    #("at", json.string(system.timestamp())),
+    #("payload", json.object([])),
+  ])
+}
+
+fn maybe_event(enabled: Bool, run_id: String, kind: String) -> Option(json.Json) {
+  case enabled {
+    True -> Some(event(kind, run_id))
+    False -> None
+  }
+}
+
+fn ensure_workspace_event(
+  events: List(json.Json),
+  run_id: String,
+) -> List(json.Json) {
+  case events {
+    [] -> [keepalive_event(run_id)]
+    _ -> [event("workspace_updated", run_id), ..events]
+  }
+}
+
+fn task_signature(tasks: List(types.Task)) -> String {
+  tasks
+  |> list.map(fn(task) {
+    task.id
+    <> ":"
+    <> types.task_state_to_string(task.state)
+    <> ":"
+    <> task.pr_number
+  })
+  |> string.join(with: "|")
+}
+
+fn delivery_signature(events: List(types.RunEvent)) -> String {
+  events
+  |> list.filter(fn(event) { event.kind == "pr_opened" })
+  |> list.map(fn(event) {
+    event.task_id
+    |> option_default("run")
+    |> fn(task_id) { task_id <> ":" <> event.message }
+  })
+  |> string.join(with: "|")
+}
+
+fn repo_state_signature(run: types.RunRecord) -> String {
+  case run.repo_state_snapshot {
+    Some(snapshot) -> snapshot.captured_at
+    None -> ""
+  }
+}
+
+fn command_signature(command_state: Option(session.CommandState)) -> String {
+  case command_state {
+    Some(state) ->
+      state.name
+      <> ":"
+      <> option_default(state.run_id, "")
+      <> ":"
+      <> state.started_at
+    None -> ""
+  }
+}
+
+fn option_default(value: Option(String), fallback: String) -> String {
+  case value {
+    Some(inner) -> inner
+    None -> fallback
+  }
+}
+
+fn choose_selected_run_id(
+  runs: List(types.RunRecord),
+  requested_run_id: Option(String),
+) -> Option(String) {
+  case requested_run_id {
+    Some(run_id) ->
+      case list.any(runs, fn(run) { run.run_id == run_id }) {
+        True -> Some(run_id)
+        False ->
+          case runs {
+            [run, ..] -> Some(run.run_id)
+            [] -> None
+          }
+      }
+    None ->
+      case runs {
+        [run, ..] -> Some(run.run_id)
+        [] -> None
+      }
+  }
+}
+
+fn compact_events(values: List(Option(json.Json))) -> List(json.Json) {
+  case values {
+    [] -> []
+    [Some(value), ..rest] -> [value, ..compact_events(rest)]
+    [None, ..rest] -> compact_events(rest)
+  }
+}
diff --git a/src/night_shift/dashboard.gleam b/src/night_shift/dashboard.gleam
index 6f00ca4..ebd2a34 100644
--- a/src/night_shift/dashboard.gleam
+++ b/src/night_shift/dashboard.gleam
@@ -1,557 +1,133 @@
-//// Minimal local dashboard surface for inspecting Night Shift runs.
+//// Thin compatibility shim over the dedicated Dash application layer.
 
 import gleam/json
-import gleam/list
-import gleam/option.{type Option, None, Some}
+import gleam/option.{None}
 import gleam/result
 import night_shift/config
-import night_shift/domain/confidence
-import night_shift/domain/provenance
-import night_shift/domain/review_run_projection
-import night_shift/domain/summary as domain_summary
-import night_shift/journal
+import night_shift/dash/api
+import night_shift/dash/assets
+import night_shift/dash/projection
+import night_shift/dash/session
 import night_shift/project
-import night_shift/repo_state_runtime
-import night_shift/report
 import night_shift/types
-import night_shift/usecase/resolve as resolve_usecase
+import night_shift/usecase/resume as resume_usecase
+import night_shift/usecase/start as start_usecase
+import simplifile
 
-/// A running local dashboard session.
-pub type Session {
-  Session(url: String, handle: String)
-}
+@external(erlang, "night_shift_dashboard_server", "http_get")
+pub fn http_get(url: String) -> Result(String, String)
+
+@external(erlang, "night_shift_dashboard_server", "http_post")
+pub fn http_post(url: String, body: String) -> Result(String, String)
 
-/// Start a read-only dashboard session for an existing run.
-@external(erlang, "night_shift_dashboard_server", "start_view_session")
 pub fn start_view_session(
   repo_root: String,
   initial_run_id: String,
-) -> Result(Session, String)
+) -> Result(session.Session, String) {
+  session_open(repo_root, initial_run_id)
+}
 
-/// Start a dashboard session that owns a live `start` invocation.
-@external(erlang, "night_shift_dashboard_server", "start_start_session")
 pub fn start_start_session(
   repo_root: String,
   initial_run_id: String,
-  run: types.RunRecord,
+  _run: types.RunRecord,
   config: types.Config,
-) -> Result(Session, String)
+) -> Result(session.Session, String) {
+  use opened <- result.try(session_open(repo_root, initial_run_id))
+  use _ <- result.try(start_usecase.execute(
+    repo_root,
+    types.RunId(initial_run_id),
+    config,
+  ))
+  Ok(opened)
+}
 
-/// Start a dashboard session that owns a live `resume` invocation.
-@external(erlang, "night_shift_dashboard_server", "start_resume_session")
 pub fn start_resume_session(
   repo_root: String,
   initial_run_id: String,
-  run: types.RunRecord,
+  _run: types.RunRecord,
   config: types.Config,
-) -> Result(Session, String)
-
-/// Stop a running dashboard session.
-@external(erlang, "night_shift_dashboard_server", "stop_session")
-pub fn stop_session(session: Session) -> Nil
-
-/// Fetch a dashboard URL from the local server.
-@external(erlang, "night_shift_dashboard_server", "http_get")
-pub fn http_get(url: String) -> Result(String, String)
-
-pub fn apply_recovery_action(
-  repo_root: String,
-  run_id: String,
-  action_name: String,
-) -> Result(String, String) {
-  use loaded_config <- result.try(load_dashboard_config(repo_root))
-  let action = case action_name {
-    "inspect" -> Ok(types.ResolveInspect)
-    "continue" -> Ok(types.ResolveContinue)
-    "abandon" -> Ok(types.ResolveAbandon)
-    _ -> Error("Unsupported dashboard recovery action: " <> action_name)
-  }
-  use resolved_action <- result.try(action)
-  use resolved <- result.try(
-    resolve_usecase.execute(
-      repo_root,
-      types.RunId(run_id),
-      None,
-      Some(resolved_action),
-      loaded_config,
-      fn(_, _) {
-        Error("Dashboard recovery does not collect planning decisions.")
-      },
-    ),
-  )
-  Ok(case resolved.summary {
-    Some(summary) -> summary <> "\nNext action: " <> resolved.next_action
-    None -> "Next action: " <> resolved.next_action
-  })
+) -> Result(session.Session, String) {
+  use opened <- result.try(session_open(repo_root, initial_run_id))
+  use _ <- result.try(resume_usecase.execute(
+    repo_root,
+    types.RunId(initial_run_id),
+    config,
+  ))
+  Ok(opened)
 }
 
-/// Render the self-contained dashboard HTML shell.
-pub fn index_html(initial_run_id: String) -> String {
-  let initial_run_json = json.string(initial_run_id) |> json.to_string
-
-  "<!doctype html>\n"
-  <> "<html lang=\"en\">\n"
-  <> "<head>\n"
-  <> "  <meta charset=\"utf-8\">\n"
-  <> "  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"
-  <> "  <title>Night Shift Dashboard</title>\n"
-  <> "  <style>\n"
-  <> "    :root { color-scheme: light; font-family: Georgia, 'Iowan Old Style', 'Palatino Linotype', serif; }\n"
-  <> "    * { box-sizing: border-box; }\n"
-  <> "    body { margin: 0; background: linear-gradient(180deg, #faf6ee 0%, #f2ede4 100%); color: #201a14; }\n"
-  <> "    .shell { min-height: 100vh; padding: 24px; }\n"
-  <> "    .hero { margin-bottom: 20px; padding: 20px 24px; border-radius: 18px; background: rgba(255, 252, 246, 0.88); border: 1px solid rgba(79, 56, 35, 0.12); box-shadow: 0 12px 40px rgba(64, 43, 24, 0.08); }\n"
-  <> "    h1, h2, h3 { margin: 0; font-weight: 600; }\n"
-  <> "    p { margin: 0; }\n"
-  <> "    .grid { display: grid; gap: 20px; grid-template-columns: minmax(240px, 320px) minmax(0, 1fr); }\n"
-  <> "    .panel { padding: 18px; border-radius: 18px; background: rgba(255, 253, 249, 0.94); border: 1px solid rgba(79, 56, 35, 0.12); box-shadow: 0 10px 30px rgba(64, 43, 24, 0.06); }\n"
-  <> "    .stack { display: grid; gap: 20px; }\n"
-  <> "    .history-list, .task-list, .event-list { margin: 0; padding: 0; list-style: none; display: grid; gap: 10px; }\n"
-  <> "    button.run-link { width: 100%; padding: 12px 14px; border-radius: 12px; border: 1px solid rgba(79, 56, 35, 0.14); background: #fffaf2; text-align: left; cursor: pointer; color: inherit; }\n"
-  <> "    button.run-link.active { background: #2f5a4a; color: #fff9ef; border-color: #2f5a4a; }\n"
-  <> "    .meta { display: grid; gap: 8px; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); margin-top: 16px; }\n"
-  <> "    .meta-card { padding: 12px 14px; border-radius: 14px; background: #f7f0e4; }\n"
-  <> "    .label { font-size: 0.8rem; text-transform: uppercase; letter-spacing: 0.08em; opacity: 0.7; }\n"
-  <> "    .value { margin-top: 4px; font-size: 0.98rem; word-break: break-word; }\n"
-  <> "    .task-row, .event-row { padding: 12px 14px; border-radius: 14px; background: #f9f3e9; }\n"
-  <> "    .recovery-panel { display: grid; gap: 12px; }\n"
-  <> "    .recovery-panel[hidden] { display: none; }\n"
-  <> "    .recovery-actions { display: flex; flex-wrap: wrap; gap: 10px; }\n"
-  <> "    button.action { padding: 10px 12px; border-radius: 12px; border: 1px solid rgba(79, 56, 35, 0.18); background: #fffaf2; cursor: pointer; }\n"
-  <> "    button.action.primary { background: #2f5a4a; color: #fff9ef; border-color: #2f5a4a; }\n"
-  <> "    .task-header, .event-header { display: flex; flex-wrap: wrap; gap: 8px; align-items: baseline; justify-content: space-between; }\n"
-  <> "    .state { display: inline-flex; align-items: center; padding: 4px 9px; border-radius: 999px; background: #e6dcc9; font-size: 0.78rem; text-transform: uppercase; letter-spacing: 0.08em; }\n"
-  <> "    pre { margin: 0; white-space: pre-wrap; word-break: break-word; font-family: 'SFMono-Regular', 'Menlo', monospace; font-size: 0.88rem; }\n"
-  <> "    .muted { opacity: 0.72; }\n"
-  <> "    @media (max-width: 900px) { .shell { padding: 16px; } .grid { grid-template-columns: 1fr; } }\n"
-  <> "  </style>\n"
-  <> "</head>\n"
-  <> "<body>\n"
-  <> "  <div class=\"shell\">\n"
-  <> "    <section class=\"hero\">\n"
-  <> "      <h1>Night Shift Dashboard</h1>\n"
-  <> "      <p class=\"muted\" id=\"status-line\">Loading run history...</p>\n"
-  <> "      <div class=\"meta\" id=\"run-meta\"></div>\n"
-  <> "    </section>\n"
-  <> "    <section class=\"grid\">\n"
-  <> "      <aside class=\"panel\">\n"
-  <> "        <h2>Runs</h2>\n"
-  <> "        <p class=\"muted\">Current repository only.</p>\n"
-  <> "        <ul class=\"history-list\" id=\"history\"></ul>\n"
-  <> "      </aside>\n"
-  <> "      <div class=\"stack\">\n"
-  <> "        <section class=\"panel\">\n"
-  <> "          <h2>Tasks</h2>\n"
-  <> "          <ul class=\"task-list\" id=\"tasks\"></ul>\n"
-  <> "        </section>\n"
-  <> "        <section class=\"panel\">\n"
-  <> "          <h2>Timeline</h2>\n"
-  <> "          <ul class=\"event-list\" id=\"events\"></ul>\n"
-  <> "        </section>\n"
-  <> "        <section class=\"panel\">\n"
-  <> "          <h2>Report</h2>\n"
-  <> "          <pre id=\"report\">Loading report...</pre>\n"
-  <> "        </section>\n"
-  <> "        <section class=\"panel recovery-panel\" id=\"recovery-panel\" hidden>\n"
-  <> "          <h2>Recovery</h2>\n"
-  <> "          <p id=\"recovery-summary\" class=\"muted\">No blocked-before-implementation recovery is active.</p>\n"
-  <> "          <div class=\"recovery-actions\">\n"
-  <> "            <button class=\"action\" id=\"recovery-inspect\" type=\"button\">Inspect</button>\n"
-  <> "            <button class=\"action primary\" id=\"recovery-continue\" type=\"button\">Continue</button>\n"
-  <> "            <button class=\"action\" id=\"recovery-abandon\" type=\"button\">Abandon</button>\n"
-  <> "          </div>\n"
-  <> "          <pre id=\"recovery-output\">Recovery guidance will appear here.</pre>\n"
-  <> "        </section>\n"
-  <> "      </div>\n"
-  <> "    </section>\n"
-  <> "  </div>\n"
-  <> "  <script>\n"
-  <> "    const initialRunId = "
-  <> initial_run_json
-  <> ";\n"
-  <> "    const terminalStates = new Set(['completed', 'blocked', 'failed']);\n"
-  <> "    let selectedRunId = initialRunId;\n"
-  <> "    let refreshTimer = null;\n"
-  <> "    async function requestJson(path) {\n"
-  <> "      const response = await fetch(path, { cache: 'no-store' });\n"
-  <> "      if (!response.ok) throw new Error('Request failed: ' + response.status);\n"
-  <> "      return response.json();\n"
-  <> "    }\n"
-  <> "    async function requestText(path, options) {\n"
-  <> "      const response = await fetch(path, Object.assign({ cache: 'no-store' }, options || {}));\n"
-  <> "      const text = await response.text();\n"
-  <> "      if (!response.ok) throw new Error(text || ('Request failed: ' + response.status));\n"
-  <> "      return text;\n"
-  <> "    }\n"
-  <> "    function renderMeta(run) {\n"
-  <> "      const fields = [\n"
-  <> "        ['Run ID', run.run_id], ['Status', run.status], ['Planning profile', run.planning_agent.profile_name], ['Planning provider', run.planning_agent.provider],\n"
-  <> "        ['Planning model', run.planning_agent.model || 'default'], ['Planning reasoning', run.planning_agent.reasoning || 'default'], ['Execution profile', run.execution_agent.profile_name], ['Execution provider', run.execution_agent.provider],\n"
-  <> "        ['Execution model', run.execution_agent.model || 'default'], ['Execution reasoning', run.execution_agent.reasoning || 'default'], ['Repo', run.repo_root], ['Created', run.created_at],\n"
-  <> "        ['Updated', run.updated_at], ['Brief', run.brief_path], ['Provenance', run.provenance_path], ['Confidence', run.confidence_posture], ['Confidence reasons', (run.confidence_reasons || []).join(' | ') || '—'], ['Max workers', String(run.max_workers)]\n"
-  <> "      ];\n"
-  <> "      if (run.repo_state) {\n"
-  <> "        fields.push(['Open PRs', String(run.repo_state.open_pr_count)]);\n"
-  <> "        fields.push(['Actionable PRs', String(run.repo_state.actionable_pr_count)]);\n"
-  <> "        fields.push(['Snapshot captured', run.repo_state.snapshot_captured_at]);\n"
-  <> "        fields.push(['Drift', run.repo_state.drift]);\n"
-  <> "      }\n"
-  <> "      document.getElementById('run-meta').innerHTML = fields.map(([label, value]) => `<div class=\"meta-card\"><div class=\"label\">${label}</div><div class=\"value\"></div></div>`).join('');\n"
-  <> "      Array.from(document.querySelectorAll('#run-meta .value')).forEach((node, index) => { node.textContent = fields[index][1] || '—'; });\n"
-  <> "      document.getElementById('status-line').textContent = `Viewing run ${run.run_id} (${run.status}).`;\n"
-  <> "    }\n"
-  <> "    function renderRecovery(run) {\n"
-  <> "      const panel = document.getElementById('recovery-panel');\n"
-  <> "      const summary = document.getElementById('recovery-summary');\n"
-  <> "      const output = document.getElementById('recovery-output');\n"
-  <> "      const blocker = run.recovery_blocker;\n"
-  <> "      const inspectButton = document.getElementById('recovery-inspect');\n"
-  <> "      const continueButton = document.getElementById('recovery-continue');\n"
-  <> "      const abandonButton = document.getElementById('recovery-abandon');\n"
-  <> "      if (!blocker) {\n"
-  <> "        panel.hidden = true;\n"
-  <> "        summary.textContent = 'No blocked-before-implementation recovery is active.';\n"
-  <> "        output.textContent = 'Recovery guidance will appear here.';\n"
-  <> "        return;\n"
-  <> "      }\n"
-  <> "      const outcome = (run.recovery_outcome_lines || []).join(' ');\n"
-  <> "      const intro = run.recovery_intro || 'Planning succeeded, but execution stopped before implementation.';\n"
-  <> "      const retryArmed = blocker.disposition === 'waived_once';\n"
-  <> "      panel.hidden = false;\n"
-  <> "      inspectButton.disabled = retryArmed;\n"
-  <> "      continueButton.disabled = retryArmed;\n"
-  <> "      abandonButton.disabled = retryArmed;\n"
-  <> "      summary.textContent = retryArmed\n"
-  <> "        ? `Retry armed for ${blocker.phase} ${blocker.kind}. ${intro} The failed gate was waived once; night-shift start will retry from there. ${outcome}`\n"
-  <> "        : `Blocked before implementation during ${blocker.phase} ${blocker.kind}. ${intro} ${blocker.message} ${outcome}`;\n"
-  <> "      output.textContent = retryArmed\n"
-  <> "        ? `Log: ${blocker.log_path}\\nNext action: night-shift start` + (blocker.task_id ? `\\nTask: ${blocker.task_id}` : '')\n"
-  <> "        : `Log: ${blocker.log_path}` + (blocker.task_id ? `\\nTask: ${blocker.task_id}` : '');\n"
-  <> "    }\n"
-  <> "    function renderHistory(runs) {\n"
-  <> "      const container = document.getElementById('history');\n"
-  <> "      container.innerHTML = '';\n"
-  <> "      runs.forEach((run) => {\n"
-  <> "        const item = document.createElement('li');\n"
-  <> "        const button = document.createElement('button');\n"
-  <> "        button.className = 'run-link' + (run.run_id === selectedRunId ? ' active' : '');\n"
-  <> "        button.type = 'button';\n"
-  <> "        button.innerHTML = `<strong>${run.run_id}</strong><br><span class=\"muted\">${run.status} · ${run.updated_at}</span>`;\n"
-  <> "        button.addEventListener('click', () => { selectedRunId = run.run_id; loadRun(true); });\n"
-  <> "        item.appendChild(button);\n"
-  <> "        container.appendChild(item);\n"
-  <> "      });\n"
-  <> "    }\n"
-  <> "    function renderTasks(tasks) {\n"
-  <> "      const container = document.getElementById('tasks');\n"
-  <> "      container.innerHTML = tasks.length === 0 ? '<li class=\"task-row muted\">No tasks have been planned yet.</li>' : '';\n"
-  <> "      tasks.forEach((task) => {\n"
-  <> "        const item = document.createElement('li');\n"
-  <> "        item.className = 'task-row';\n"
-  <> "        item.innerHTML = `<div class=\"task-header\"><strong>${task.title}</strong><span class=\"state\">${task.state}</span></div><p class=\"muted\">${task.id}</p><p>${task.summary || task.description || 'No summary yet.'}</p><p class=\"muted\">Branch: ${task.branch_name || '—'} · PR: ${task.pr_number || '—'}</p>`;\n"
-  <> "        container.appendChild(item);\n"
-  <> "      });\n"
-  <> "    }\n"
-  <> "    function renderEvents(events) {\n"
-  <> "      const container = document.getElementById('events');\n"
-  <> "      container.innerHTML = events.length === 0 ? '<li class=\"event-row muted\">No events recorded yet.</li>' : '';\n"
-  <> "      events.forEach((event) => {\n"
-  <> "        const item = document.createElement('li');\n"
-  <> "        item.className = 'event-row';\n"
-  <> "        item.innerHTML = `<div class=\"event-header\"><strong>${event.kind}</strong><span class=\"muted\">${event.at}</span></div><p>${event.message}</p><p class=\"muted\">Task: ${event.task_id || 'run-wide'}</p>`;\n"
-  <> "        container.appendChild(item);\n"
-  <> "      });\n"
-  <> "    }\n"
-  <> "    function scheduleRefresh(isActive) {\n"
-  <> "      if (refreshTimer) clearTimeout(refreshTimer);\n"
-  <> "      refreshTimer = setTimeout(() => loadRun(false), isActive ? 2000 : 10000);\n"
-  <> "    }\n"
-  <> "    async function performRecovery(action) {\n"
-  <> "      if (!selectedRunId) return;\n"
-  <> "      const output = document.getElementById('recovery-output');\n"
-  <> "      output.textContent = 'Working...';\n"
-  <> "      try {\n"
-  <> "        const text = await requestText(`/api/runs/${encodeURIComponent(selectedRunId)}/recovery/${action}`, { method: 'POST' });\n"
-  <> "        output.textContent = text;\n"
-  <> "        await loadRun(true);\n"
-  <> "      } catch (error) {\n"
-  <> "        output.textContent = error.message;\n"
-  <> "      }\n"
-  <> "    }\n"
-  <> "    async function loadRun(forceHistoryRefresh) {\n"
-  <> "      const runs = await requestJson('/api/runs');\n"
-  <> "      if (!selectedRunId && runs.length > 0) selectedRunId = runs[0].run_id;\n"
-  <> "      if (!selectedRunId) {\n"
-  <> "        document.getElementById('status-line').textContent = 'No runs found for this repository.';\n"
-  <> "        document.getElementById('history').innerHTML = '';\n"
-  <> "        document.getElementById('tasks').innerHTML = '';\n"
-  <> "        document.getElementById('events').innerHTML = '';\n"
-  <> "        document.getElementById('report').textContent = 'No report available.';\n"
-  <> "        scheduleRefresh(false);\n"
-  <> "        return;\n"
-  <> "      }\n"
-  <> "      if (forceHistoryRefresh || !runs.some((run) => run.run_id === selectedRunId)) {\n"
-  <> "        selectedRunId = runs[0].run_id;\n"
-  <> "      }\n"
-  <> "      renderHistory(runs);\n"
-  <> "      const payload = await requestJson('/api/runs/' + encodeURIComponent(selectedRunId));\n"
-  <> "      renderMeta(payload.run);\n"
-  <> "      renderRecovery(payload.run);\n"
-  <> "      renderTasks(payload.run.tasks);\n"
-  <> "      renderEvents(payload.events);\n"
-  <> "      document.getElementById('report').textContent = payload.report;\n"
-  <> "      scheduleRefresh(!terminalStates.has(payload.run.status));\n"
-  <> "    }\n"
-  <> "    document.getElementById('recovery-inspect').addEventListener('click', () => performRecovery('inspect'));\n"
-  <> "    document.getElementById('recovery-continue').addEventListener('click', () => performRecovery('continue'));\n"
-  <> "    document.getElementById('recovery-abandon').addEventListener('click', () => performRecovery('abandon'));\n"
-  <> "    loadRun(true).catch((error) => { document.getElementById('status-line').textContent = error.message; scheduleRefresh(false); });\n"
-  <> "  </script>\n"
-  <> "</body>\n"
-  <> "</html>\n"
+pub fn stop_session(opened: session.Session) -> Nil {
+  session.stop_session(opened)
 }
 
-/// Encode the repository's run history as dashboard JSON.
 pub fn runs_json(repo_root: String) -> Result(String, String) {
-  use runs <- result.try(journal.list_runs(repo_root))
-  Ok(
-    runs
-    |> list.map(run_summary_json)
-    |> json.array(identity)
-    |> json.to_string,
-  )
+  use workspace <- result.try(api.workspace_json(repo_root, None))
+  Ok(workspace)
 }
 
-/// Encode one run, its events, and its report as dashboard JSON.
 pub fn run_json(repo_root: String, run_id: String) -> Result(String, String) {
-  use #(run, events) <- result.try(journal.load(repo_root, types.RunId(run_id)))
-  let repo_state_view = load_repo_state_view(run)
-  let review_projection =
-    review_run_projection.build(run, events, repo_state_view)
-  let confidence_assessment = confidence.assess(run, events, repo_state_view)
-  let rendered_report = report.render_live(run, events, repo_state_view)
+  let #(config, initialized) = load_repo_config(repo_root)
+  let command_state = session.command_state(repo_root)
+  use run_payload <- result.try(projection.load_run_projection(
+    repo_root,
+    run_id,
+    config,
+  ))
   Ok(
     json.object([
-      #("run", run_detail_json(run, review_projection, confidence_assessment)),
-      #("events", json.array(events, event_json)),
-      #("report", json.string(rendered_report)),
+      #("initialized", json.bool(initialized)),
+      #(
+        "command_state",
+        json.nullable(from: command_state, of: command_state_json),
+      ),
+      #("run", json.nullable(from: run_payload, of: identity_json)),
     ])
     |> json.to_string,
   )
 }
 
-fn run_summary_json(run: types.RunRecord) -> json.Json {
-  json.object([
-    #("run_id", json.string(run.run_id)),
-    #("status", json.string(types.run_status_to_string(run.status))),
-    #("planning_agent", agent_json(run.planning_agent)),
-    #("execution_agent", agent_json(run.execution_agent)),
-    #("created_at", json.string(run.created_at)),
-    #("updated_at", json.string(run.updated_at)),
-    #("brief_path", json.string(run.brief_path)),
-  ])
-}
-
-fn run_detail_json(
-  run: types.RunRecord,
-  review_projection: Option(review_run_projection.ReviewRunProjection),
-  confidence_assessment: types.ConfidenceAssessment,
-) -> json.Json {
-  json.object([
-    #("run_id", json.string(run.run_id)),
-    #("repo_root", json.string(run.repo_root)),
-    #("run_path", json.string(run.run_path)),
-    #("brief_path", json.string(run.brief_path)),
-    #("report_path", json.string(run.report_path)),
-    #("provenance_path", json.string(provenance.artifact_path(run))),
-    #("planning_agent", agent_json(run.planning_agent)),
-    #("execution_agent", agent_json(run.execution_agent)),
-    #(
-      "confidence_posture",
-      json.string(types.confidence_posture_to_string(
-        confidence_assessment.posture,
-      )),
-    ),
-    #(
-      "confidence_reasons",
-      json.array(confidence_assessment.reasons, json.string),
-    ),
-    #("max_workers", json.int(run.max_workers)),
-    #("status", json.string(types.run_status_to_string(run.status))),
-    #("created_at", json.string(run.created_at)),
-    #("updated_at", json.string(run.updated_at)),
-    #(
-      "recovery_blocker",
-      json.nullable(from: run.recovery_blocker, of: recovery_blocker_json),
-    ),
-    #(
-      "recovery_intro",
-      json.nullable(from: recovery_intro(run), of: json.string),
-    ),
-    #(
-      "recovery_outcome_lines",
-      json.array(recovery_outcome_lines(run), json.string),
-    ),
-    #(
-      "replacement_pr_numbers",
-      json.array(replacement_pr_numbers(run.tasks), json.int),
-    ),
-    #(
-      "repo_state",
-      json.nullable(
-        from: projection_repo_state(review_projection),
-        of: repo_state_json,
-      ),
-    ),
-    #("tasks", json.array(run.tasks, task_json)),
-  ])
-}
-
-fn task_json(task: types.Task) -> json.Json {
-  json.object([
-    #("id", json.string(task.id)),
-    #("title", json.string(task.title)),
-    #("description", json.string(task.description)),
-    #("state", json.string(types.task_state_to_string(task.state))),
-    #("branch_name", json.string(task.branch_name)),
-    #("pr_number", json.string(task.pr_number)),
-    #("summary", json.string(task.summary)),
-  ])
-}
-
-fn recovery_blocker_json(blocker: types.RecoveryBlocker) -> json.Json {
-  json.object([
-    #("kind", json.string(types.recovery_blocker_kind_to_string(blocker.kind))),
-    #(
-      "phase",
-      json.string(types.recovery_blocker_phase_to_string(blocker.phase)),
-    ),
-    #("task_id", json.nullable(from: blocker.task_id, of: json.string)),
-    #("message", json.string(blocker.message)),
-    #("log_path", json.string(blocker.log_path)),
-    #("no_changes_produced", json.bool(blocker.no_changes_produced)),
-    #(
-      "disposition",
-      json.string(case blocker.disposition {
-        types.RecoveryBlocking -> "blocking"
-        types.RecoveryWaivedOnce -> "waived_once"
-      }),
-    ),
-  ])
-}
-
-fn recovery_intro(run: types.RunRecord) -> Option(String) {
-  case run.recovery_blocker {
-    Some(_) -> Some(domain_summary.setup_recovery_intro(run))
-    None -> None
-  }
-}
-
-fn recovery_outcome_lines(run: types.RunRecord) -> List(String) {
-  case run.recovery_blocker {
-    Some(_) -> domain_summary.setup_recovery_outcome_lines(run)
-    None -> []
-  }
-}
-
-fn load_repo_state_view(
-  run: types.RunRecord,
-) -> Option(repo_state_runtime.RepoStateView) {
-  case config.load(project.config_path(run.repo_root)) {
-    Ok(loaded_config) ->
-      repo_state_runtime.inspect(run, loaded_config.branch_prefix).view
-    Error(_) -> None
-  }
+pub fn apply_recovery_action(
+  repo_root: String,
+  run_id: String,
+  action_name: String,
+) -> Result(String, String) {
+  api.recovery_action(repo_root, run_id, action_name, "{}")
 }
 
-fn repo_state_json(summary: review_run_projection.RepoStateSummary) -> json.Json {
-  json.object([
-    #("snapshot_captured_at", json.string(summary.snapshot_captured_at)),
-    #(
-      "open_pr_count",
-      json.int(review_run_projection.current_or_captured_open_count(summary)),
-    ),
-    #(
-      "actionable_pr_count",
-      json.int(review_run_projection.current_or_captured_actionable_count(
-        summary,
-      )),
-    ),
-    #(
-      "drift",
-      json.string(case summary.drift {
-        Some(drift) -> drift
-        None -> "unknown"
-      }),
-    ),
-  ])
+pub fn index_html(initial_run_id: String) -> Result(String, String) {
+  assets.app_shell(initial_run_id)
 }
 
-fn projection_repo_state(
-  review_projection: Option(review_run_projection.ReviewRunProjection),
-) -> Option(review_run_projection.RepoStateSummary) {
-  case review_projection {
-    Some(projection) -> Some(projection.repo_state)
-    None -> None
+fn session_open(
+  repo_root: String,
+  initial_run_id: String,
+) -> Result(session.Session, String) {
+  use _ <- result.try(assets.ensure_assets_ready())
+  session.open(repo_root, initial_run_id)
+}
+
+fn load_repo_config(repo_root: String) -> #(types.Config, Bool) {
+  let config_path = project.config_path(repo_root)
+  case simplifile.read(config_path) {
+    Ok(contents) ->
+      case config.parse(contents) {
+        Ok(parsed) -> #(parsed, True)
+        Error(_) -> #(types.default_config(), False)
+      }
+    Error(_) -> #(types.default_config(), False)
   }
 }
 
-fn agent_json(agent: types.ResolvedAgentConfig) -> json.Json {
+fn command_state_json(state: session.CommandState) -> json.Json {
   json.object([
-    #("profile_name", json.string(agent.profile_name)),
-    #("provider", json.string(types.provider_to_string(agent.provider))),
-    #("model", case agent.model {
-      Some(model) -> json.string(model)
-      None -> json.null()
-    }),
-    #("reasoning", case agent.reasoning {
-      Some(reasoning) -> json.string(types.reasoning_to_string(reasoning))
-      None -> json.null()
-    }),
+    #("name", json.string(state.name)),
+    #("run_id", json.nullable(from: state.run_id, of: json.string)),
+    #("started_at", json.string(state.started_at)),
+    #("summary", json.string(state.summary)),
   ])
 }
 
-fn event_json(event: types.RunEvent) -> json.Json {
-  json.object([
-    #("kind", json.string(event.kind)),
-    #("at", json.string(event.at)),
-    #("message", json.string(event.message)),
-    #("task_id", case event.task_id {
-      Some(task_id) -> json.string(task_id)
-      None -> json.null()
-    }),
-  ])
-}
-
-fn identity(value: json.Json) -> json.Json {
+fn identity_json(value: json.Json) -> json.Json {
   value
 }
-
-fn replacement_pr_numbers(tasks: List(types.Task)) -> List(Int) {
-  unique_pr_numbers(
-    tasks
-      |> list.flat_map(fn(task) { task.superseded_pr_numbers }),
-    [],
-  )
-}
-
-fn unique_pr_numbers(values: List(Int), acc: List(Int)) -> List(Int) {
-  case values {
-    [] -> list.reverse(acc)
-    [value, ..rest] ->
-      case list.contains(acc, value) {
-        True -> unique_pr_numbers(rest, acc)
-        False -> unique_pr_numbers(rest, [value, ..acc])
-      }
-  }
-}
-
-fn load_dashboard_config(repo_root: String) -> Result(types.Config, String) {
-  case config.load(project.config_path(repo_root)) {
-    Ok(loaded_config) -> Ok(loaded_config)
-    Error(message) ->
-      Error(
-        "Unable to load Night Shift config for dashboard recovery: " <> message,
-      )
-  }
-}
diff --git a/src/night_shift/demo.gleam b/src/night_shift/demo.gleam
index dd1fb79..e6c8b18 100644
--- a/src/night_shift/demo.gleam
+++ b/src/night_shift/demo.gleam
@@ -145,6 +145,7 @@ fn run_ui_demo(repo_root: String, demo_root: String) -> Result(String, String) {
   ))
   use _ <- result.try(start_ui_command(repo_root, demo_root, log_path, pid_path))
   use #(url, run_id) <- result.try(wait_for_ui_details(log_path, 40))
+  use _ <- result.try(start_dashboard_run(url, run_id))
   use payload <- result.try(wait_for_completed_dashboard_payload(
     url,
     run_id,
@@ -181,7 +182,7 @@ fn run_ui_demo(repo_root: String, demo_root: String) -> Result(String, String) {
   }
   |> result.map(fn(_) {
     "Demo succeeded.\n"
-    <> "Validated UI flows: plan, start --ui, dashboard payload, status\n"
+    <> "Validated UI flows: plan, dash, dashboard start, dashboard payload, status\n"
     <> "Dashboard: "
     <> url
     <> "\n"
@@ -300,7 +301,7 @@ fn start_ui_command(
 ) -> Result(Nil, String) {
   let command =
     "nohup "
-    <> build_cli_command(["start", "--ui"])
+    <> build_cli_command(["dash"])
     <> " > "
     <> shell.quote(log_path)
     <> " 2>&1 & echo $! > "
@@ -314,6 +315,14 @@ fn start_ui_command(
   )
 }
 
+fn start_dashboard_run(url: String, run_id: String) -> Result(Nil, String) {
+  case dashboard.http_post(url <> "/api/runs/" <> run_id <> "/start", "{}") {
+    Ok(_) -> Ok(Nil)
+    Error(message) ->
+      Error("Unable to start the demo run from Dash. " <> message)
+  }
+}
+
 fn stop_ui_command(demo_root: String, pid_path: String) -> Result(Nil, String) {
   run_checked(
     "kill $(cat " <> shell.quote(pid_path) <> ")",
diff --git a/src/night_shift/infra/dashboard_session.gleam b/src/night_shift/infra/dashboard_session.gleam
index aba09a9..1d97c41 100644
--- a/src/night_shift/infra/dashboard_session.gleam
+++ b/src/night_shift/infra/dashboard_session.gleam
@@ -9,6 +9,20 @@ import night_shift/usecase/support/environment
 import night_shift/usecase/support/repo_guard
 import night_shift/usecase/support/runs
 
+pub fn view(
+  repo_root: String,
+  selector: types.RunSelector,
+) -> Result(Nil, String) {
+  use initial_run_id <- result.try(resolve_initial_run_id(repo_root, selector))
+  use session <- result.try(dashboard.start_view_session(
+    repo_root,
+    initial_run_id,
+  ))
+  io.println(render_dashboard_summary(session.url, initial_run_id))
+  system.wait_forever()
+  Ok(Nil)
+}
+
 pub fn start(
   repo_root: String,
   selector: types.RunSelector,
@@ -51,5 +65,30 @@ pub fn resume(
 }
 
 fn render_dashboard_summary(url: String, run_id: String) -> String {
-  "Dashboard: " <> url <> "\n" <> "Run: " <> run_id
+  "Dashboard: "
+  <> url
+  <> "\nRun: "
+  <> case run_id {
+    "" -> "(auto)"
+    value -> value
+  }
+}
+
+fn resolve_initial_run_id(
+  repo_root: String,
+  selector: types.RunSelector,
+) -> Result(String, String) {
+  case selector {
+    types.RunId(run_id) -> {
+      use _ <- result.try(journal.load(repo_root, selector))
+      Ok(run_id)
+    }
+    types.LatestRun -> {
+      use run_list <- result.try(journal.list_runs(repo_root))
+      Ok(case run_list {
+        [run, ..] -> run.run_id
+        [] -> ""
+      })
+    }
+  }
 }
diff --git a/src/night_shift/types.gleam b/src/night_shift/types.gleam
index da38a03..5820bb7 100644
--- a/src/night_shift/types.gleam
+++ b/src/night_shift/types.gleam
@@ -775,7 +775,8 @@ pub fn default_config() -> Config {
 
 /// Parsed CLI commands for the operator-facing executable.
 pub type Command {
-  Start(run: RunSelector, ui_enabled: Bool)
+  Start(run: RunSelector)
+  Dash(run: RunSelector)
   Init(agent_overrides: AgentOverrides, generate_setup: Bool, assume_yes: Bool)
   Reset(assume_yes: Bool, force: Bool)
   Plan(
@@ -797,7 +798,7 @@ pub type Command {
     task_id: Option(String),
     action: Option(ResolveAction),
   )
-  Resume(run: RunSelector, ui_enabled: Bool, explain_only: Bool)
+  Resume(run: RunSelector, explain_only: Bool)
   Demo(ui_enabled: Bool)
   Help
 }
diff --git a/src/night_shift_dashboard_server.erl b/src/night_shift_dashboard_server.erl
index 19fd99a..dbec21d 100644
--- a/src/night_shift_dashboard_server.erl
+++ b/src/night_shift_dashboard_server.erl
@@ -1,32 +1,34 @@
 -module(night_shift_dashboard_server).
 
--export([start_view_session/2, start_start_session/4, start_resume_session/4, stop_session/1, http_get/1]).
+-export([
+    start_session/2,
+    stop_session/1,
+    command_state/1,
+    http_get/1,
+    http_post/2
+]).
 
--define(TABLE, night_shift_dashboard_sessions).
--define(HOST, "127.0.0.1").
--define(START_PORT, 8787).
--define(END_PORT, 8797).
+-define(SESSIONS_TABLE, night_shift_dashboard_sessions).
+-define(COMMANDS_TABLE, night_shift_dashboard_commands).
 
-start_view_session(RepoRoot, InitialRunId) ->
-    start_session(RepoRoot, InitialRunId, undefined).
-
-start_start_session(RepoRoot, InitialRunId, Run, Config) ->
-    start_session(
-        RepoRoot,
-        InitialRunId,
-        fun() -> run_start(Run, Config) end
-    ).
-
-start_resume_session(RepoRoot, InitialRunId, Run, Config) ->
-    start_session(
-        RepoRoot,
-        InitialRunId,
-        fun() -> run_resume(Run, Config) end
-    ).
+start_session(RepoRoot, InitialRunId) ->
+    ensure_tables(),
+    case listen() of
+        {ok, Listener, Port} ->
+            Handle = integer_to_binary(erlang:unique_integer([positive, monotonic])),
+            ServerPid =
+                spawn(fun() ->
+                    accept_loop(Listener, RepoRoot, InitialRunId)
+                end),
+            ets:insert(?SESSIONS_TABLE, {Handle, ServerPid}),
+            {ok, {session, build_url(Port), Handle}};
+        {error, Message} ->
+            {error, Message}
+    end.
 
 stop_session({session, _Url, Handle}) ->
-    ensure_table(),
-    case ets:take(?TABLE, Handle) of
+    ensure_tables(),
+    case ets:take(?SESSIONS_TABLE, Handle) of
         [{Handle, Pid}] ->
             exit(Pid, shutdown),
             nil;
@@ -34,56 +36,54 @@ stop_session({session, _Url, Handle}) ->
             nil
     end.
 
+command_state(RepoRoot) ->
+    ensure_tables(),
+    case ets:lookup(?COMMANDS_TABLE, RepoRoot) of
+        [{RepoRoot, Name, RunId, StartedAt, Summary}] ->
+            {some, {command_state, Name, run_id_option(RunId), StartedAt, Summary}};
+        [] ->
+            none
+    end.
+
 http_get(Url) ->
+    request(get, Url, <<>>).
+
+http_post(Url, Body) ->
+    request(post, Url, Body).
+
+request(Method, Url, Body) ->
     application:ensure_all_started(inets),
-    case httpc:request(get, {binary_to_list(Url), []}, [], [{body_format, binary}]) of
-        {ok, {{_, Status, _}, _Headers, Body}} when Status >= 200, Status < 300 ->
-            {ok, Body};
-        {ok, {{_, Status, _}, _Headers, Body}} ->
-            {error, <<(integer_to_binary(Status))/binary, ": ", Body/binary>>};
+    Request =
+        case Method of
+            get -> {binary_to_list(Url), []};
+            post ->
+                {binary_to_list(Url), [], "application/json", binary_to_list(Body)}
+        end,
+    case httpc:request(Method, Request, [], [{body_format, binary}]) of
+        {ok, {{_, Status, _}, _Headers, ResponseBody}} when Status >= 200, Status < 300 ->
+            {ok, ResponseBody};
+        {ok, {{_, Status, _}, _Headers, ResponseBody}} ->
+            {error, <<(integer_to_binary(Status))/binary, ": ", ResponseBody/binary>>};
         {error, Reason} ->
             {error, unicode:characters_to_binary(io_lib:format("~p", [Reason]))}
     end.
 
-start_session(RepoRoot, InitialRunId, Runner) ->
-    ensure_table(),
-    case listen(?START_PORT) of
-        {ok, Listener, Port} ->
-            Handle = integer_to_binary(erlang:unique_integer([positive, monotonic])),
-            ServerPid =
-                spawn(fun() ->
-                    maybe_spawn_runner(Runner),
-                    accept_loop(Listener, RepoRoot, InitialRunId)
-                end),
-            ets:insert(?TABLE, {Handle, ServerPid}),
-            {ok, {session, build_url(Port), Handle}};
-        {error, Message} ->
-            {error, Message}
-    end.
-
-listen(Port) when Port =< ?END_PORT ->
+listen() ->
     case gen_tcp:listen(
-        Port,
+        0,
         [binary, {active, false}, {packet, raw}, {ip, {127, 0, 0, 1}}, {reuseaddr, true}]
     ) of
         {ok, Listener} ->
-            {ok, Listener, Port};
-        {error, eaddrinuse} ->
-            listen(Port + 1);
+            case inet:sockname(Listener) of
+                {ok, {_Address, Port}} ->
+                    {ok, Listener, Port};
+                {error, Reason} ->
+                    gen_tcp:close(Listener),
+                    {error, format_error("Unable to determine dashboard port", Reason)}
+            end;
         {error, Reason} ->
-            {error, unicode:characters_to_binary(io_lib:format("Unable to start dashboard server: ~p", [Reason]))}
-    end;
-listen(_) ->
-    {error, <<"Unable to start dashboard server on 127.0.0.1:8787-8797.">>}.
-
-build_url(Port) ->
-    <<"http://127.0.0.1:", (integer_to_binary(Port))/binary>>.
-
-maybe_spawn_runner(undefined) ->
-    ok;
-maybe_spawn_runner(Runner) ->
-    spawn(fun() -> Runner() end),
-    ok.
+            {error, format_error("Unable to start dashboard server", Reason)}
+    end.
 
 accept_loop(Listener, RepoRoot, InitialRunId) ->
     case gen_tcp:accept(Listener) of
@@ -98,63 +98,264 @@ accept_loop(Listener, RepoRoot, InitialRunId) ->
 
 handle_client(Socket, RepoRoot, InitialRunId) ->
     Request = read_request(Socket, <<>>),
-    case parse_request(Request) of
-        {ok, <<"GET">>, <<"/">>} ->
-            reply(Socket, 200, <<"text/html; charset=utf-8">>, night_shift@dashboard:index_html(InitialRunId));
-        {ok, <<"GET">>, <<"/api/runs">>} ->
-            case night_shift@dashboard:runs_json(RepoRoot) of
+    KeepOpen =
+        case parse_request(Request) of
+            {ok, Method, Path, Query, Body} ->
+                dispatch(Socket, RepoRoot, InitialRunId, Method, Path, Query, Body);
+            error ->
+                reply(Socket, 400, <<"text/plain; charset=utf-8">>, <<"Bad request">>),
+                close
+        end,
+    case KeepOpen of
+        keep_open -> ok;
+        close -> gen_tcp:close(Socket)
+    end.
+
+dispatch(Socket, RepoRoot, InitialRunId, <<"GET">>, <<"/">>, _Query, _Body) ->
+    case night_shift@dash@assets:app_shell(InitialRunId) of
+        {ok, Html} ->
+            reply(Socket, 200, <<"text/html; charset=utf-8">>, Html),
+            close;
+        {error, Message} ->
+            reply(Socket, 500, <<"text/plain; charset=utf-8">>, Message),
+            close
+    end;
+dispatch(Socket, _RepoRoot, _InitialRunId, <<"GET">>, <<"/assets/", Rest/binary>>, _Query, _Body) ->
+    Segments = split_path(Rest),
+    case night_shift@dash@assets:read_asset(Segments) of
+        {ok, Contents} ->
+            ContentType = night_shift@dash@assets:content_type(Segments),
+            reply(Socket, 200, ContentType, Contents),
+            close;
+        {error, Message} ->
+            reply(Socket, 404, <<"text/plain; charset=utf-8">>, Message),
+            close
+    end;
+dispatch(Socket, RepoRoot, _InitialRunId, <<"GET">>, <<"/api/workspace">>, Query, _Body) ->
+    case night_shift@dash@api:workspace_json(RepoRoot, query_run(Query)) of
+        {ok, Payload} ->
+            reply(Socket, 200, <<"application/json; charset=utf-8">>, Payload),
+            close;
+        {error, Message} ->
+            reply(Socket, 400, <<"text/plain; charset=utf-8">>, Message),
+            close
+    end;
+dispatch(Socket, RepoRoot, _InitialRunId, <<"GET">>, <<"/api/init/models">>, Query, _Body) ->
+    case maps:get(<<"provider">>, Query, undefined) of
+        undefined ->
+            reply(Socket, 400, <<"text/plain; charset=utf-8">>, <<"Missing provider query parameter">>),
+            close;
+        Provider ->
+            case night_shift@dash@api:init_models_json(RepoRoot, Provider) of
                 {ok, Payload} ->
-                    reply(Socket, 200, <<"application/json; charset=utf-8">>, Payload);
+                    reply(Socket, 200, <<"application/json; charset=utf-8">>, Payload),
+                    close;
                 {error, Message} ->
-                    reply(Socket, 500, <<"text/plain; charset=utf-8">>, Message)
-            end;
-        {ok, <<"POST">>, <<"/api/runs/", Rest/binary>>} ->
-            case parse_recovery_path(Rest) of
-                {ok, RunId, Action} ->
-                    case night_shift@dashboard:apply_recovery_action(RepoRoot, uri_string:unquote(RunId), Action) of
-                        {ok, Payload} ->
-                            reply(Socket, 200, <<"text/plain; charset=utf-8">>, Payload);
-                        {error, Message} ->
-                            reply(Socket, 400, <<"text/plain; charset=utf-8">>, Message)
-                    end;
-                error ->
-                    reply(Socket, 404, <<"text/plain; charset=utf-8">>, <<"Not found">>)
-            end;
-        {ok, <<"GET">>, <<"/api/runs/", RunId/binary>>} ->
-            case night_shift@dashboard:run_json(RepoRoot, uri_string:unquote(RunId)) of
+                    reply(Socket, 400, <<"text/plain; charset=utf-8">>, Message),
+                    close
+            end
+    end;
+dispatch(Socket, RepoRoot, _InitialRunId, <<"GET">>, <<"/api/runs">>, _Query, _Body) ->
+    case night_shift@dashboard:runs_json(RepoRoot) of
+        {ok, Payload} ->
+            reply(Socket, 200, <<"application/json; charset=utf-8">>, Payload),
+            close;
+        {error, Message} ->
+            reply(Socket, 400, <<"text/plain; charset=utf-8">>, Message),
+            close
+    end;
+dispatch(Socket, RepoRoot, _InitialRunId, <<"GET">>, <<"/api/runs/", Rest/binary>>, Query, _Body) ->
+    case parse_run_path(Rest) of
+        {events, RunId} ->
+            sse_reply(Socket),
+            stream_events(
+                Socket,
+                RepoRoot,
+                case RunId of
+                    <<"latest">> -> none;
+                    _ -> some_string(RunId)
+                end,
+                none
+            ),
+            keep_open;
+        {run, RunId} ->
+            case night_shift@dashboard:run_json(RepoRoot, unquote_binary(RunId)) of
                 {ok, Payload} ->
-                    reply(Socket, 200, <<"application/json; charset=utf-8">>, Payload);
+                    reply(Socket, 200, <<"application/json; charset=utf-8">>, Payload),
+                    close;
                 {error, Message} ->
-                    reply(Socket, 404, <<"text/plain; charset=utf-8">>, Message)
+                    reply(Socket, 404, <<"text/plain; charset=utf-8">>, Message),
+                    close
             end;
-        {ok, <<"GET">>, _Path} ->
-            reply(Socket, 404, <<"text/plain; charset=utf-8">>, <<"Not found">>);
-        {ok, _Method, _Path} ->
-            reply(Socket, 405, <<"text/plain; charset=utf-8">>, <<"Method not allowed">>);
         error ->
-            reply(Socket, 400, <<"text/plain; charset=utf-8">>, <<"Bad request">>)
-    end,
-    gen_tcp:close(Socket).
+            reply(Socket, 404, <<"text/plain; charset=utf-8">>, <<"Not found">>),
+            close
+    end;
+dispatch(Socket, RepoRoot, _InitialRunId, <<"GET">>, <<"/artifacts/runs/", Rest/binary>>, _Query, _Body) ->
+    case parse_artifact_path(Rest) of
+        {ok, RunId, Segments} ->
+            serve_artifact(Socket, RepoRoot, unquote_binary(RunId), Segments);
+        error ->
+            reply(Socket, 404, <<"text/plain; charset=utf-8">>, <<"Not found">>),
+            close
+    end;
+dispatch(Socket, RepoRoot, _InitialRunId, <<"POST">>, <<"/api/init">>, _Query, Body) ->
+    handle_sync_command(Socket, RepoRoot, <<"init">>, <<>>, fun() ->
+        night_shift@dash@api:init_action(RepoRoot, Body)
+    end);
+dispatch(Socket, RepoRoot, _InitialRunId, <<"POST">>, <<"/api/plans">>, _Query, Body) ->
+    handle_sync_command(Socket, RepoRoot, <<"plan">>, <<>>, fun() ->
+        night_shift@dash@api:plan_action(RepoRoot, Body, false)
+    end);
+dispatch(Socket, RepoRoot, _InitialRunId, <<"POST">>, <<"/api/plans/from-reviews">>, _Query, Body) ->
+    handle_sync_command(Socket, RepoRoot, <<"plan_from_reviews">>, <<>>, fun() ->
+        night_shift@dash@api:plan_action(RepoRoot, Body, true)
+    end);
+dispatch(Socket, RepoRoot, _InitialRunId, <<"POST">>, <<"/api/runs/", Rest/binary>>, _Query, Body) ->
+    case parse_run_command_path(Rest) of
+        {start, RunId} ->
+            handle_async_command(Socket, RepoRoot, <<"start">>, unquote_binary(RunId), fun() ->
+                night_shift@dash@api:start_command(RepoRoot, unquote_binary(RunId))
+            end);
+        {resume, RunId} ->
+            handle_async_command(Socket, RepoRoot, <<"resume">>, unquote_binary(RunId), fun() ->
+                night_shift@dash@api:resume_command(RepoRoot, unquote_binary(RunId))
+            end);
+        {resolve_decisions, RunId} ->
+            handle_sync_command(Socket, RepoRoot, <<"resolve_decisions">>, unquote_binary(RunId), fun() ->
+                night_shift@dash@api:resolve_decisions_action(
+                    RepoRoot,
+                    unquote_binary(RunId),
+                    Body
+                )
+            end);
+        {recovery, RunId, Action} ->
+            handle_sync_command(Socket, RepoRoot, <<"recovery">>, unquote_binary(RunId), fun() ->
+                night_shift@dash@api:recovery_action(
+                    RepoRoot,
+                    unquote_binary(RunId),
+                    unquote_binary(Action),
+                    Body
+                )
+            end);
+        error ->
+            reply(Socket, 404, <<"text/plain; charset=utf-8">>, <<"Not found">>),
+            close
+    end;
+dispatch(Socket, _RepoRoot, _InitialRunId, <<"GET">>, _Path, _Query, _Body) ->
+    reply(Socket, 404, <<"text/plain; charset=utf-8">>, <<"Not found">>),
+    close;
+dispatch(Socket, _RepoRoot, _InitialRunId, _Method, _Path, _Query, _Body) ->
+    reply(Socket, 405, <<"text/plain; charset=utf-8">>, <<"Method not allowed">>),
+    close.
+
+handle_sync_command(Socket, RepoRoot, Name, RunId, Fun) ->
+    case begin_command(RepoRoot, Name, RunId) of
+        ok ->
+            Response =
+                try Fun() of
+                    {ok, Payload} ->
+                        finish_command(RepoRoot),
+                        {200, <<"application/json; charset=utf-8">>, Payload};
+                    {error, Message} ->
+                        finish_command(RepoRoot),
+                        {400, <<"text/plain; charset=utf-8">>, Message}
+                catch
+                    Class:Reason:Stack ->
+                        finish_command(RepoRoot),
+                        {500, <<"text/plain; charset=utf-8">>, format_crash(Class, Reason, Stack)}
+                end,
+            reply(Socket, element(1, Response), element(2, Response), element(3, Response)),
+            close;
+        {error, Message} ->
+            reply(Socket, 409, <<"text/plain; charset=utf-8">>, Message),
+            close
+    end.
+
+handle_async_command(Socket, RepoRoot, Name, RunId, Fun) ->
+    case begin_command(RepoRoot, Name, RunId) of
+        ok ->
+            spawn(fun() ->
+                try Fun() of
+                    _ -> ok
+                catch
+                    _:_:_ -> ok
+                after
+                    finish_command(RepoRoot)
+                end
+            end),
+            reply(
+                Socket,
+                202,
+                <<"application/json; charset=utf-8">>,
+                async_payload(Name, RunId)
+            ),
+            close;
+        {error, Message} ->
+            reply(Socket, 409, <<"text/plain; charset=utf-8">>, Message),
+            close
+    end.
+
+async_payload(Name, RunId) ->
+    iolist_to_binary([
+        <<"{\"ok\":true,\"summary\":\"Dash started ">>,
+        Name,
+        <<" for run ">>,
+        RunId,
+        <<".\",\"next_action\":\"Watch Dash for live updates.\",\"run_id\":\"">>,
+        RunId,
+        <<"\"}">>
+    ]).
+
+serve_artifact(Socket, RepoRoot, RunId, Segments) ->
+    case night_shift@dash@api:artifact_contents(RepoRoot, RunId, Segments) of
+        {ok, {ContentType, Contents}} ->
+            reply(Socket, 200, ContentType, Contents),
+            close;
+        {error, Message} ->
+            reply(Socket, 404, <<"text/plain; charset=utf-8">>, Message),
+            close
+    end.
 
 read_request(Socket, Acc) ->
-    case gen_tcp:recv(Socket, 0) of
-        {ok, Data} ->
-            Next = <<Acc/binary, Data/binary>>,
-            case binary:match(Next, <<"\r\n\r\n">>) of
-                {_, _} -> Next;
-                nomatch when byte_size(Next) < 65536 -> read_request(Socket, Next);
-                nomatch -> Next
+    case binary:match(Acc, <<"\r\n\r\n">>) of
+        {HeaderEnd, 4} ->
+            Headers = binary:part(Acc, 0, HeaderEnd + 4),
+            ContentLength = content_length(Headers),
+            BodyLength = byte_size(Acc) - (HeaderEnd + 4),
+            case BodyLength >= ContentLength of
+                true ->
+                    Acc;
+                false ->
+                    case gen_tcp:recv(Socket, 0) of
+                        {ok, Data} -> read_request(Socket, <<Acc/binary, Data/binary>>);
+                        {error, _Reason} -> Acc
+                    end
             end;
-        {error, _Reason} ->
-            Acc
+        nomatch ->
+            case gen_tcp:recv(Socket, 0) of
+                {ok, Data} when byte_size(Acc) + byte_size(Data) < 1048576 ->
+                    read_request(Socket, <<Acc/binary, Data/binary>>);
+                {ok, Data} ->
+                    <<Acc/binary, Data/binary>>;
+                {error, _Reason} ->
+                    Acc
+            end
     end.
 
 parse_request(Request) ->
-    case binary:split(Request, <<"\r\n">>, [global]) of
-        [RequestLine | _] ->
-            case binary:split(RequestLine, <<" ">>, [global]) of
-                [Method, RawPath, _Version] ->
-                    {ok, Method, strip_query(RawPath)};
+    case binary:split(Request, <<"\r\n\r\n">>) of
+        [HeaderBin, Body] ->
+            Lines = binary:split(HeaderBin, <<"\r\n">>, [global]),
+            case Lines of
+                [RequestLine | HeaderLines] ->
+                    case binary:split(RequestLine, <<" ">>, [global]) of
+                        [Method, RawPath, _Version] ->
+                            {Path, Query} = split_query(RawPath),
+                            {ok, Method, Path, parse_query(Query), Body};
+                        _ ->
+                            error
+                    end;
                 _ ->
                     error
             end;
@@ -162,21 +363,85 @@ parse_request(Request) ->
             error
     end.
 
-strip_query(Path) ->
-    case binary:split(Path, <<"?">>) of
-        [Clean | _] -> Clean;
-        [] -> Path
+split_query(RawPath) ->
+    case binary:split(RawPath, <<"?">>) of
+        [Path, Query] -> {Path, Query};
+        [Path] -> {Path, <<>>}
     end.
 
-parse_recovery_path(Rest) ->
-    case binary:split(Rest, <<"/recovery/">>) of
-        [RunId, Action] when RunId =/= <<>>, Action =/= <<>> ->
-            {ok, RunId, Action};
-        _ ->
-            error
+parse_query(<<>>) -> #{};
+parse_query(Query) ->
+    lists:foldl(
+        fun(Pair, Acc) ->
+            case binary:split(Pair, <<"=">>) of
+                [Key, Value] ->
+                    maps:put(Key, unquote_binary(Value), Acc);
+                [Key] ->
+                    maps:put(Key, <<>>, Acc)
+            end
+        end,
+        #{},
+        binary:split(Query, <<"&">>, [global])
+    ).
+
+content_length(Headers) ->
+    Lines = binary:split(Headers, <<"\r\n">>, [global]),
+    case lists:dropwhile(
+        fun(Line) ->
+            not lists:prefix("content-length:", string:lowercase(binary_to_list(Line)))
+        end,
+        Lines
+    ) of
+        [Line | _] ->
+            case binary:split(Line, <<":">>) of
+                [_Key, Value] ->
+                    binary_to_integer(
+                        unicode:characters_to_binary(
+                            string:trim(binary_to_list(Value), both, " ")
+                        )
+                    );
+                _ ->
+                    0
+            end;
+        [] ->
+            0
+    end.
+
+sse_reply(Socket) ->
+    Response =
+        <<
+            "HTTP/1.1 200 OK\r\n",
+            "Content-Type: text/event-stream\r\n",
+            "Cache-Control: no-store\r\n",
+            "Connection: keep-alive\r\n\r\n"
+        >>,
+    ok = gen_tcp:send(Socket, Response).
+
+stream_events(Socket, RepoRoot, RunOption, Previous) ->
+    Current = case night_shift@dash@stream:snapshot(RepoRoot, RunOption) of
+        {ok, Value} -> Value;
+        {error, _} -> none
+    end,
+    Events = night_shift@dash@stream:diff_events(Previous, Current),
+    case send_sse_events(Socket, Events) of
+        ok ->
+            timer:sleep(1000),
+            stream_events(Socket, RepoRoot, RunOption, Current);
+        closed ->
+            ok
+    end.
+
+send_sse_events(_Socket, []) ->
+    ok;
+send_sse_events(Socket, [Event | Rest]) ->
+    Payload = night_shift@dash@stream:event_json(Event),
+    Frame = <<"data: ", Payload/binary, "\n\n">>,
+    case gen_tcp:send(Socket, Frame) of
+        ok -> send_sse_events(Socket, Rest);
+        {error, _} -> closed
     end.
 
-reply(Socket, StatusCode, ContentType, Body) ->
+reply(Socket, StatusCode, ContentType, Body) when is_binary(ContentType), is_binary(Body) ->
     StatusLine = status_line(StatusCode),
     Response =
         <<
@@ -187,47 +452,102 @@ reply(Socket, StatusCode, ContentType, Body) ->
             "Connection: close\r\n\r\n",
             Body/binary
         >>,
-    ok = gen_tcp:send(Socket, Response).
+    ok = gen_tcp:send(Socket, Response);
+reply(Socket, StatusCode, ContentType, Body) when is_list(Body) ->
+    reply(Socket, StatusCode, ContentType, unicode:characters_to_binary(Body));
+reply(Socket, StatusCode, ContentType, Body) when is_list(ContentType) ->
+    reply(Socket, StatusCode, unicode:characters_to_binary(ContentType), Body).
 
 status_line(200) -> <<"200 OK">>;
+status_line(202) -> <<"202 Accepted">>;
 status_line(400) -> <<"400 Bad Request">>;
 status_line(404) -> <<"404 Not Found">>;
 status_line(405) -> <<"405 Method Not Allowed">>;
+status_line(409) -> <<"409 Conflict">>;
 status_line(500) -> <<"500 Internal Server Error">>.
 
-run_start(Run, Config) ->
-    case night_shift@orchestrator:start(Run, Config) of
-        {ok, _CompletedRun} ->
+ensure_tables() ->
+    ensure_table(?SESSIONS_TABLE),
+    ensure_table(?COMMANDS_TABLE).
+
+ensure_table(Name) ->
+    case ets:info(Name) of
+        undefined ->
+            ets:new(Name, [named_table, public, set]),
             ok;
-        {error, Message} ->
-            mark_failed(Run, Message)
+        _ ->
+            ok
     end.
 
-run_resume(Run, Config) ->
-    case night_shift@orchestrator:resume(Run, Config) of
-        {ok, _CompletedRun} ->
+begin_command(RepoRoot, Name, RunId) ->
+    ensure_tables(),
+    case ets:lookup(?COMMANDS_TABLE, RepoRoot) of
+        [] ->
+            ets:insert(
+                ?COMMANDS_TABLE,
+                {RepoRoot, Name, empty_to_undefined(RunId), night_shift_system:timestamp(), <<"Running command">>}
+            ),
             ok;
-        {error, Message} ->
-            mark_failed(Run, Message)
+        _ ->
+            {error, <<"Another Dash command is already running for this repository.">>}
     end.
 
-mark_failed(Run, Message) ->
-    RepoRoot = erlang:element(3, Run),
-    RunId = erlang:element(2, Run),
-    case night_shift@journal:load(RepoRoot, {run_id, RunId}) of
-        {ok, {LatestRun, _Events}} ->
-            _ = night_shift@journal:mark_status(LatestRun, run_failed, Message),
-            ok;
-        {error, _} ->
-            _ = night_shift@journal:mark_status(Run, run_failed, Message),
-            ok
+finish_command(RepoRoot) ->
+    ets:delete(?COMMANDS_TABLE, RepoRoot),
+    ok.
+
+build_url(Port) ->
+    <<"http://127.0.0.1:", (integer_to_binary(Port))/binary>>.
+
+run_id_option(<<>>) -> none;
+run_id_option(undefined) -> none;
+run_id_option(RunId) -> {some, RunId}.
+
+query_run(Query) ->
+    case maps:get(<<"run">>, Query, undefined) of
+        undefined -> none;
+        <<"latest">> -> none;
+        <<>> -> none;
+        RunId -> {some, RunId}
     end.
 
-ensure_table() ->
-    case ets:info(?TABLE) of
-        undefined ->
-            ets:new(?TABLE, [named_table, public, set]),
-            ok;
+some_string(Value) -> {some, Value}.
+
+empty_to_undefined(<<>>) -> undefined;
+empty_to_undefined(Value) -> Value.
+
+format_error(Prefix, Reason) ->
+    unicode:characters_to_binary(io_lib:format("~s: ~p", [Prefix, Reason])).
+
+format_crash(Class, Reason, Stack) ->
+    unicode:characters_to_binary(io_lib:format("~p:~p ~p", [Class, Reason, Stack])).
+
+unquote_binary(Value) ->
+    unicode:characters_to_binary(uri_string:unquote(binary_to_list(Value))).
+
+split_path(Path) ->
+    [Segment || Segment <- binary:split(Path, <<"/">>, [global]), Segment =/= <<>>].
+
+parse_run_path(Rest) ->
+    case split_path(Rest) of
+        [RunId, <<"events">>] -> {events, RunId};
+        [RunId] -> {run, RunId};
+        _ -> error
+    end.
+
+parse_run_command_path(Rest) ->
+    case split_path(Rest) of
+        [RunId, <<"start">>] -> {start, RunId};
+        [RunId, <<"resume">>] -> {resume, RunId};
+        [RunId, <<"resolve">>, <<"decisions">>] -> {resolve_decisions, RunId};
+        [RunId, <<"recovery">>, Action] -> {recovery, RunId, Action};
+        _ -> error
+    end.
+
+parse_artifact_path(Rest) ->
+    case split_path(Rest) of
+        [RunId | Segments] when Segments =/= [] ->
+            {ok, RunId, [unquote_binary(Segment) || Segment <- Segments]};
         _ ->
-            ok
+            error
     end.
diff --git a/test/night_shift_cli_config_test.gleam b/test/night_shift_cli_config_test.gleam
index df7b314..4e6d4b0 100644
--- a/test/night_shift_cli_config_test.gleam
+++ b/test/night_shift_cli_config_test.gleam
@@ -7,7 +7,7 @@ import night_shift/types
 import night_shift/worktree_setup
 
 pub fn parse_start_command_test() {
-  let assert Ok(types.Start(types.RunId("run-123"), False)) =
+  let assert Ok(types.Start(types.RunId("run-123"))) =
     cli.parse(["start", "--run", "run-123"])
 }
 
@@ -66,13 +66,29 @@ pub fn parse_status_defaults_to_latest_test() {
   let assert Ok(types.Status(types.LatestRun)) = cli.parse(["status"])
 }
 
-pub fn parse_start_command_with_ui_test() {
-  let assert Ok(types.Start(types.LatestRun, True)) =
-    cli.parse(["start", "--ui"])
+pub fn parse_start_command_rejects_ui_flag_test() {
+  let assert Error(message) = cli.parse(["start", "--ui"])
+  assert message
+    == "`start --ui` was replaced by `night-shift dash`, which now owns the browser flow."
+}
+
+pub fn parse_dash_command_defaults_to_latest_test() {
+  let assert Ok(types.Dash(types.LatestRun)) = cli.parse(["dash"])
+}
+
+pub fn parse_dash_command_with_run_selector_test() {
+  let assert Ok(types.Dash(types.RunId("run-123"))) =
+    cli.parse(["dash", "--run", "run-123"])
+}
+
+pub fn parse_dash_command_rejects_transitional_start_flag_test() {
+  let assert Error(message) = cli.parse(["dash", "--start"])
+  assert message
+    == "`night-shift dash --start` was removed; open Dash and use the Start button in the browser."
 }
 
 pub fn parse_start_command_without_brief_test() {
-  let assert Ok(types.Start(types.LatestRun, False)) = cli.parse(["start"])
+  let assert Ok(types.Start(types.LatestRun)) = cli.parse(["start"])
 }
 
 pub fn parse_plan_requires_notes_test() {
@@ -126,13 +142,14 @@ pub fn parse_resolve_rejects_multiple_actions_test() {
     == "`night-shift resolve --task <task-id>` accepts exactly one of `--inspect`, `--continue`, `--complete`, or `--abandon`."
 }
 
-pub fn parse_resume_command_with_ui_test() {
-  let assert Ok(types.Resume(types.RunId("run-123"), True, False)) =
-    cli.parse(["resume", "--run", "run-123", "--ui"])
+pub fn parse_resume_command_rejects_ui_flag_test() {
+  let assert Error(message) = cli.parse(["resume", "--run", "run-123", "--ui"])
+  assert message
+    == "`resume --ui` was replaced by `night-shift dash`, which now owns the browser flow."
 }
 
 pub fn parse_resume_explain_command_test() {
-  let assert Ok(types.Resume(types.LatestRun, False, True)) =
+  let assert Ok(types.Resume(types.LatestRun, True)) =
     cli.parse(["resume", "--explain"])
 }
 
diff --git a/test/night_shift_dashboard_demo_test.gleam b/test/night_shift_dashboard_demo_test.gleam
index edd8dec..6ce66c8 100644
--- a/test/night_shift_dashboard_demo_test.gleam
+++ b/test/night_shift_dashboard_demo_test.gleam
@@ -167,7 +167,7 @@ pub fn demo_run_succeeds_with_ui_test() {
 
   assert string.contains(
     does: summary,
-    contain: "Validated UI flows: plan, start --ui, dashboard payload, status",
+    contain: "Validated UI flows: plan, dash, dashboard start, dashboard payload, status",
   )
   assert string.contains(does: summary, contain: "Dashboard: http://127.0.0.1:")
   assert string.contains(