Add DELETE /api/metrics/{name} to allow deleting a declared metric (ticket 051)

Wires the engine's existing RemoveMetricDeclaration message (previously
only used internally by delete_profile's cleanup) up to a new DELETE
route, persists the removal into the active profile so it survives a
restart, and adds a delete affordance in the Metrics UI.

Decisions:
- Bucket-value history under the deleted metric's name is purged, not
  left orphaned (engine.rs's new remove_metric_declaration reuses
  update_metric's clear_metric_data helper). This is what lets a
  dashboard panel or PromQL query still referencing the metric by name
  fail with a readable "unknown metric" error instead of silently
  returning stale data.
- evaluate_promql now errors when a metric has neither a declaration nor
  any bucket data, since a metric ingested via --metrics-url scraping
  never gets a MetricDeclaration but must stay queryable. Verified with
  a seeded fixture (promql_query_against_deleted_metric_fails_with_readable_error
  in src/api.rs).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XFUNZwCvz3kcod3352ZR2o

src/api.rs

@@ -115,6 +115,21 @@ impl ApiState {
             );
         }
     }
+
+    /// Best-effort, matching `persist_param_declaration`'s intent — a no-op if no profile is
+    /// active, and I/O failures are only logged, since the engine's removal is already the source
+    /// of truth for what the live process shows.
+    fn persist_metric_declaration_removal(&self, name: &str) {
+        let mut settings = self.settings.lock().unwrap();
+        let Some(profile_name) = settings.active_profile.clone() else {
+            return;
+        };
+        if let Err(err) = settings.remove_metric_declaration(&self.settings_path, &profile_name, name) {
+            eprintln!(
+                "warning: failed to remove metric declaration '{name}' from profile '{profile_name}': {err}"
+            );
+        }
+    }
 }
 
 pub fn router(engine: EngineHandle, settings: SettingsHandle, settings_path: PathBuf) -> Router {
@@ -132,7 +147,7 @@ pub fn router(engine: EngineHandle, settings: SettingsHandle, settings_path: Pat
         .route("/api/metrics", get(list_metrics).post(declare_metric))
         .route(
             "/api/metrics/{name}",
-            get(get_metric_bucket_values).put(update_metric),
+            get(get_metric_bucket_values).put(update_metric).delete(delete_metric),
         )
         .route("/api/query", get(run_promql_query))
         .route("/api/settings", get(get_settings).patch(update_settings))
@@ -395,6 +410,35 @@ async fn update_metric(
     }
 }
 
+/// Deletes the metric declaration named by the URL path — both from the live engine index and,
+/// if a profile is active, from persisted settings (ticket 051), so it doesn't reappear on
+/// restart. Its recorded bucket-value history is purged along with it (see the comment on
+/// `EngineMessage::RemoveMetricDeclaration`'s handler in `engine.rs`), rather than left orphaned,
+/// so a dashboard panel or PromQL query still referencing the metric by name fails with a clear
+/// "unknown metric" error instead of silently keeping stale data alive.
+async fn delete_metric(
+    State(state): State<ApiState>,
+    AxumPath(name): AxumPath<String>,
+) -> impl IntoResponse {
+    let (respond_to, response) = oneshot::channel();
+    if state
+        .engine
+        .send(EngineMessage::RemoveMetricDeclaration { name: name.clone(), respond_to })
+        .await
+        .is_err()
+    {
+        return StatusCode::SERVICE_UNAVAILABLE.into_response();
+    }
+    match response.await {
+        Ok(true) => {
+            state.persist_metric_declaration_removal(&name);
+            StatusCode::NO_CONTENT.into_response()
+        }
+        Ok(false) => StatusCode::NOT_FOUND.into_response(),
+        Err(_) => StatusCode::SERVICE_UNAVAILABLE.into_response(),
+    }
+}
+
 /// Malformed pairs (no `=`) are skipped rather than rejected.
 fn parse_labels_filter(raw: &str) -> BTreeMap<String, String> {
     raw.split(',')
@@ -1106,6 +1150,112 @@ mod tests {
         assert!(body["error"].as_str().unwrap().contains("duration"));
     }
 
+    #[tokio::test]
+    async fn deletes_metric_and_it_disappears_from_the_list() {
+        let (app, _engine, _settings, _dir) = test_app();
+        send_json(
+            &app,
+            "POST",
+            "/api/metrics",
+            json!({
+                "name": "requests",
+                "message_match_regex": r"request path=(?P<path>\S+)",
+                "label_params": []
+            }),
+        )
+        .await;
+
+        let status = delete_request(&app, "/api/metrics/requests").await;
+        assert_eq!(status, StatusCode::NO_CONTENT);
+
+        let (status, body) = get_json(&app, "/api/metrics").await;
+        assert_eq!(status, StatusCode::OK);
+        assert!(body.as_array().unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn deleting_unknown_metric_name_returns_404_not_500() {
+        let (app, _engine, _settings, _dir) = test_app();
+        let status = delete_request(&app, "/api/metrics/does-not-exist").await;
+        assert_eq!(status, StatusCode::NOT_FOUND);
+    }
+
+    /// Acceptance criterion: deleting a metric persists the removal into the active profile too, so
+    /// it doesn't reappear from `settings.json` on the next restart.
+    #[tokio::test]
+    async fn deleting_metric_persists_removal_and_it_does_not_reappear_after_restart() {
+        let (app, _engine, settings_handle, dir) = test_app();
+
+        let settings_path = dir.path().join("settings.json");
+        {
+            let mut settings = settings_handle.lock().unwrap();
+            settings.create_profile(&settings_path, "web".to_string()).unwrap();
+            settings.set_active_profile(&settings_path, Some("web".to_string())).unwrap();
+        }
+
+        send_json(
+            &app,
+            "POST",
+            "/api/metrics",
+            json!({
+                "name": "requests",
+                "message_match_regex": r"request path=(?P<path>\S+)",
+                "label_params": []
+            }),
+        )
+        .await;
+        assert_eq!(Settings::load(&settings_path).profile("web").unwrap().metrics.len(), 1);
+
+        let status = delete_request(&app, "/api/metrics/requests").await;
+        assert_eq!(status, StatusCode::NO_CONTENT);
+
+        assert!(Settings::load(&settings_path).profile("web").unwrap().metrics.is_empty());
+    }
+
+    /// Acceptance criterion: a dashboard panel (PromQL query) that still references a metric by
+    /// name after it's been deleted fails with a readable "unknown metric" error, rather than a
+    /// panic or a silently-empty series — seeded here by declaring, ingesting into, deleting, then
+    /// re-querying the same metric name.
+    #[tokio::test]
+    async fn promql_query_against_deleted_metric_fails_with_readable_error() {
+        let (app, engine, _settings, _dir) = test_app();
+
+        declare_test_param(&app, "path", r"request path=(?P<path>\S+)", "path", "string").await;
+        send_json(
+            &app,
+            "POST",
+            "/api/metrics",
+            json!({
+                "name": "requests",
+                "message_match_regex": r"request path=(?P<path>\S+)",
+                "label_params": ["path"]
+            }),
+        )
+        .await;
+        engine
+            .send(EngineMessage::Ingest(IngestedLine {
+                sequence: 0,
+                timestamp: Timestamp::from_millis(0),
+                text: "request path=/a".to_string(),
+            }))
+            .await
+            .unwrap();
+
+        // Sanity check: the dashboard-panel-style query works before deletion.
+        let (status, _body) = get_json(&app, "/api/query?promql=requests").await;
+        assert_eq!(status, StatusCode::OK);
+
+        let status = delete_request(&app, "/api/metrics/requests").await;
+        assert_eq!(status, StatusCode::NO_CONTENT);
+
+        let (status, body) = get_json(&app, "/api/query?promql=requests").await;
+        assert_eq!(status, StatusCode::BAD_REQUEST);
+        assert!(
+            body["error"].as_str().unwrap().contains("unknown metric"),
+            "expected a readable 'unknown metric' error, got: {body}"
+        );
+    }
+
     #[tokio::test]
     async fn queries_bucket_values_with_label_filter_and_range() {
         let (app, engine, _settings, _dir) = test_app();