detectkit 0.41.0__tar.gz → 0.42.0__tar.gz

{detectkit-0.41.0/detectkit.egg-info → detectkit-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.41.0
+Version: 0.42.0
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/__init__.py

@@ -4,7 +4,7 @@ detectk - Anomaly Detection for Time-Series Metrics
 A Python library for data analysts and engineers to monitor metrics with automatic anomaly detection.
 """
 
-__version__ = "0.41.0"
+__version__ = "0.42.0"
 
 from detectkit.core.interval import Interval
 from detectkit.core.models import ColumnDefinition, TableModel

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/autotune/__init__.py

@@ -15,7 +15,6 @@ from detectkit.autotune._base import AutoTuneError, _AutoTuneBase
 from detectkit.autotune._types import ScoringMetric, TuneMode
 from detectkit.autotune.autotuner import AutoTuner, run_autotune_engine
 from detectkit.autotune.config_emitter import compute_run_id, emit_tuned_config
-from detectkit.autotune.html_labeler import render_labeler_html
 from detectkit.autotune.labels import (
     GroundTruth,
     IncidentLabels,
@@ -39,6 +38,5 @@ __all__ = [
     "emit_tuned_config",
     "parse_incident_labels",
     "parse_labels_file",
-    "render_labeler_html",
     "run_autotune_engine",
 ]

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/cli/assets/claude/CLAUDE.section.md

@@ -17,10 +17,12 @@ run. But you assist far better with **read access to the same database** (e.g. a
 database MCP for the project's ClickHouse / PostgreSQL / MySQL): you can inspect
 a metric's series, find real incidents to label for `dtk autotune`, sanity-check
 a metric query before running it, and confirm detections — instead of asking the
-user to run every query by hand. Without it, fall back to
-`dtk autotune --select <metric> --label` (a visual labeler) and to asking the
-user. This access is optional and separate from the `profiles.yml` connection
-detectkit uses for the pipeline.
+user to run every query by hand. Without it, fall back to marking incidents
+visually in `dtk tune --select <metric>` (**Label** mode to drag spans / Threshold
+capture / Lasso the anomaly cloud, or **Review** mode to confirm fired alerts as
+incidents), then **Save incidents** — which `dtk autotune` auto-discovers in
+`incidents/<metric>/` — and to asking the user. This access is optional and
+separate from the `profiles.yml` connection detectkit uses for the pipeline.
 
 ### Where to look (read the matching file before answering)
 

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/cli/assets/claude/rules/autotune.md

@@ -64,28 +64,24 @@ ratios to choose.
 ## Command
 
 ```bash
-dtk autotune --select <sel> [--incidents FILE] [--label] [--scoring METRIC] \
+dtk autotune --select <sel> [--incidents FILE] [--scoring METRIC] \
              [--from DATE] [--to DATE] [--profile NAME] [--force] [--dry-run] [--report]
 ```
 
 - `--incidents FILE|DIR` — a labels file (below) → **supervised** tuning. May be a
   **directory** (e.g. `incidents/<name>/`): interactive runs prompt to pick a
-  version (default newest), non-interactive use the newest. With nothing given, an
+  version (default newest), non-interactive use the newest. **Omit it and `dtk
+  autotune` auto-discovers the newest labels in `incidents/<metric>/`** (the store
+  `dtk tune`'s **Save incidents** writes) — so after labeling in `dtk tune` you run
+  `dtk autotune --select <metric>` with no flag. With no labels anywhere, an
   interactive terminal prompts to enter incidents inline; declining (or running
   non-interactively) tunes **unsupervised**.
-- `--label` — open the interactive labeler (zoom/pan, edit incident edges,
-  per-incident descriptions, named sets). **Default:** a local 127.0.0.1 server +
-  browser; **Save & tune** writes `incidents/<metric>/<metric>[-<set>]-<UTC>.yml`
-  (named after the metric, optional set name as a suffix) and the run
-  **continues into tuning on it**. It **seeds from the metric's newest saved set**
-  (or from `--incidents FILE|DIR` when given), so re-running `--label` continues
-  editing in place. Beyond click-drag marking it offers **Threshold capture**
-  (grab every span above/below a horizontal line in one gesture), **Lasso capture**
-  (loop around a cloud of points; each grid-adjacent run, gaps bridged, becomes one
-  incident span), **on-chart delete** (each band's ✕, or select + Delete key), and
-  **Import file…** (load a labels file you pick). `--no-serve` writes a static
-  `metrics/<name>__labeler.html` (Export downloads the file) and exits; `--no-open`
-  prints the URL instead of launching a browser.
+- **To label incidents**, use `dtk tune --select <metric>`: switch to **Label**
+  mode (drag spans, **Threshold capture** every span past a horizontal line,
+  **Lasso** the anomaly cloud) or **Review** mode (confirm fired alerts as
+  incidents), then **Save incidents**. That writes versioned files into
+  `incidents/<metric>/` — the **same store this command reads** — so the labels feed
+  the next supervised tune with no `--incidents` flag (see `cli.md`).
 - `--scoring` — `mcc` (default), `f1`, `f_beta`, `balanced_accuracy`, `roc_auc`,
   `pr_auc`. MCC uses the whole confusion matrix and suits rare anomalies.
 - `--dry-run` — run the search but persist nothing and write no config.
@@ -115,45 +111,35 @@ incidents:
   - {at: "2026-05-11 09:05:00"}                                  # point
 ```
 
-### Getting labels — offer the interactive labeler first
+### Getting labels — label in `dtk tune` first
 
-When labels would help, **offer the interactive HTML labeler before asking the
+When labels would help, **offer to mark incidents in `dtk tune` before asking the
 user to recall timestamps** — it is the easiest, most reliable path:
 
-1. Run `dtk autotune --select <name> --label`. It starts a local labeler server
-   and opens the browser (use `--no-open` on a remote box and share the printed
-   127.0.0.1 URL; the user port-forwards or runs it locally).
-2. The user marks incidents on the chart (scroll to zoom, drag the navigator to
-   move, click-drag to mark, drag an incident's edges to adjust, add a
-   description, optionally name the set), then clicks **Save & tune**. For many
-   clear outliers, **Threshold capture** grabs every span past a horizontal line
-   at once (above/below, with an optional gap-bridge); it captures within the
-   current view by default, and dragging across the chart limits it to a time
-   window (different boundary per period) — the painted window is **saved with the
-   set and restored on reopen** (a `capture_windows:` block; metadata only). For an
-   irregular cloud, **Lasso capture** loops around the points freehand and turns
-   each grid-adjacent run (small gaps bridged) into one incident span. Each
-   band's ✕ (or select + Delete)
-   removes one, and **focus** on a list row jumps the chart to it.
-3. That writes `incidents/<metric>/<metric>[-<set>]-<UTC>.yml` automatically
-   (named after the metric, optional set name as a suffix; versioned —
-   re-labeling never overwrites) and the **same command continues into the tuning
-   run** on it. No manual file moving.
-4. **Editing over time:** re-running `--label` seeds the page from the metric's
-   newest saved set, so labeling can grow across sessions. To re-tune later on
-   saved sets, point `--incidents` at the folder (`incidents/<name>/`) —
-   interactive runs let the user pick a version, and `--label --incidents <file>`
-   opens that exact set for editing. The static `--no-serve` path still exists
-   (Export downloads a file you move into `incidents/<name>/`; its **Import
-   file…** button loads one back in).
+1. Run `dtk tune --select <name>`. It opens a localhost browser view of the real
+   series (use `--no-open` on a remote box and share the printed 127.0.0.1 URL).
+2. Mark the real incidents one of two ways:
+   - **Label** mode — drag a span over each incident, or **Threshold capture**
+     every span past a horizontal line in one gesture, or **Lasso anomalies** to
+     loop a cloud of anomaly dots into per-streak incident spans.
+   - **Review** mode — the fired alerts lead; click each alert marker to confirm it
+     **valid** (which marks it as a ground-truth incident) or **false alarm**.
+     **Confirm all unreviewed valid** does the lot — a clean metric whose alerts
+     are all good is validated in a few clicks without hand-drawing spans.
+3. Click **Save incidents**. It writes a versioned
+   `incidents/<metric>/<…>.yml` automatically.
+4. Run `dtk autotune --select <name>` with **no `--incidents` flag** — it
+   auto-discovers the newest file in `incidents/<metric>/` and tunes supervised on
+   it. (You can still pass `--incidents <file-or-dir>` to pick a specific set.)
 
 Prefer this whenever the user can *recognise* incidents on a chart but doesn't
 have exact times. If they already know the times (or you found them via a DB
 MCP), write the labels file / inline `incidents:` directly instead. If there are
 no known incidents, run unsupervised — the baseline below is good on its own.
 
-With no labels (no `--incidents`, no config `labels_file`, no interactive
-entry), tuning falls back to an **unsupervised** objective that blends three
+With no labels (no `--incidents`, no config `labels_file`, none auto-discovered
+in `incidents/<metric>/`, no interactive entry), tuning falls back to an
+**unsupervised** objective that blends three
 band-fit / flag-budget terms — `0.4·budget + 0.3·sharpness + 0.3·separation`: a
 smooth one-sided flag-rate budget (no hard cliff), sharpness (a tight,
 well-calibrated confidence interval), and separation (flagged points sitting
@@ -192,8 +178,10 @@ differs from `seasonality_candidates`, which only narrows the *set of columns*
 the search may consider but still runs the search and may choose none.
 
 Label precedence (highest first): `--incidents` flag → `labels_file` → inline
-`incidents` → interactive prompt → none. `labels_file` and `incidents` are
-mutually exclusive. `--scoring` likewise overrides `scoring_metric`.
+`incidents` → auto-discovered `incidents/<metric>/` (the newest file, e.g. from
+`dtk tune`'s **Save incidents**) → interactive prompt → none (unsupervised).
+`labels_file` and `incidents` are mutually exclusive. `--scoring` likewise
+overrides `scoring_metric`.
 
 ## The annotated config
 

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/cli/assets/claude/rules/cli.md

@@ -67,8 +67,11 @@ Automatically chooses a metric's seasonality, detector type, hyperparameters and
 history window, then writes an annotated `metrics/<name>__tuned_<id>.yml`. Reads
 the metric's loaded datapoints (run `dtk run --steps load` first if empty), never
 edits the original, never alerts. `--incidents FILE` enables supervised tuning
-against labeled incidents; without it, an unsupervised objective is used.
-`--dry-run` searches without writing. `--report [PATH]` writes the same
+against labeled incidents; omit it and autotune **auto-discovers** the newest
+labels in `incidents/<metric>/` (the store `dtk tune`'s **Save incidents** writes
+— label there in Label/Review mode, then just run `dtk autotune`); with no labels
+anywhere, an unsupervised objective is used. `--dry-run` searches without writing.
+`--report [PATH]` writes the same
 self-contained HTML report as `dtk run` for the tuned winner (default
 `reports/<metric>__tuned_<id>.html`; `<dir>` or a `.html` file also accepted).
 Full reference: `autotune.md`.

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/cli/assets/claude/skills/dtk-autotune/SKILL.md

@@ -79,44 +79,39 @@ generalize is rejected.
 Labels turn tuning from a good unsupervised default into a config optimised
 against *your* real incidents (it then optimises MCC and also tunes the alert
 window `consecutive_anomalies`). **The easiest, most reliable way to produce them
-is the interactive HTML labeler — offer this first**, before asking the user to
+is to mark incidents in `dtk tune` — offer this first**, before asking the user to
 recall timestamps:
 
 ```bash
-dtk autotune --select <name> --label
+dtk tune --select <name>
 ```
 
-By default this starts a **local labeler server** (127.0.0.1) and opens the
-browser; on a remote machine add `--no-open` and share the printed URL. Walk the
-user through it:
+This opens a localhost browser view of the metric's **real** series; on a remote
+machine add `--no-open` and share the printed URL. Walk the user through it:
 
 1. Navigate a long/dense series: **scroll to zoom**, double-click to reset, drag
-   the **navigator strip** to move the view (window = pan, edges = stretch).
-2. **Click-drag across the chart** to mark each incident (red band + a row below
-   with an optional **description**). Adjust one by dragging its **edges**, or its
-   **middle** to move it; optionally **name the set**. Remove one by clicking its
-   **✕** on the chart (or selecting it and pressing **Delete**) — no hunting in
-   the list; **focus** on a list row jumps the chart to that incident; *Clear all*
-   resets.
-3. When many outliers are obvious, use **Threshold capture**: set a horizontal
-   line (hover the chart or type a value), pick **above/below**, optionally bridge
-   small gaps, and **Add N spans** marks them all at once — then tidy with the ✕.
-   It captures within the current view by default; **drag across the chart** to
-   limit it to a time window (so a metric that behaves differently across periods
-   can take a different boundary in each). **↺ whole view** clears the window.
-4. Click **Save & tune**. The server writes `incidents/<metric>/<metric>[-<set>]-<UTC>.yml`
-   automatically (named after the metric, with the optional set name as a suffix;
-   versioned — re-labeling never overwrites) and the **same command
-   continues into the tuning run on it**. No manual file moving.
-
-**Editing an existing set:** re-running `--label` **seeds the page from the
-metric's newest saved set** (or from `--label --incidents <file-or-dir>`), so
-labeling can grow across sessions — mark a few more, save a new version. (`--no-serve`
-is the offline fallback: it writes a static `metrics/<name>__labeler.html` whose
-Export downloads a versioned file you then move into `incidents/<name>/` and pass
-via `--incidents`; its **Import file…** button loads a saved set back in.) To
-re-tune later on a saved set, point `--incidents` at `incidents/<name>/`
-(interactive runs let the user pick a version).
+   the **navigator strip** to move the view.
+2. Mark the real incidents in one of two modes:
+   - **Label** mode — **drag a span** over each incident (edges to resize, middle
+     to move, ✕/Delete to remove). When many outliers are obvious, **Threshold
+     capture** grabs every span past a horizontal line in one gesture (set the
+     line, pick the side, optionally bridge gaps); **Lasso anomalies** loops a
+     freeform cloud of anomaly dots into one incident span per grid-adjacent run.
+   - **Review** mode — the fired alerts lead; **click each alert marker** to cycle
+     its verdict un-reviewed → **valid** (green) → **false alarm** (slate).
+     **Confirming an alert valid marks it as a ground-truth incident**, and
+     **Confirm all unreviewed valid** does the lot — so a clean metric whose alerts
+     are all good is validated in a few clicks without hand-drawing spans.
+3. Click **Save incidents**. It writes `incidents/<metric>/<…>.yml` automatically
+   (versioned — saving never overwrites). Saving doesn't end the session, so you
+   can keep tuning; you can also click **Apply** to write the detector config back.
+
+**Then run autotune with no `--incidents` flag** — `dtk autotune --select <name>`
+**auto-discovers the newest file in `incidents/<metric>/`** (the same store
+`dtk tune` saves to) and tunes supervised on it. To re-tune on a specific set,
+pass `--incidents <file-or-dir>` (point it at `incidents/<name>/` and interactive
+runs let the user pick a version). Labeling grows across sessions — reopen
+`dtk tune`, mark a few more, **Save incidents** again, re-run autotune.
 
 Prefer this whenever the user can *recognise* incidents on a chart but doesn't
 have exact timestamps — it is far easier than dictating times, and they label
@@ -158,10 +153,14 @@ is good on its own; it just can't learn *which* spikes you specifically care abo
 ## Step 3 — Run autotune
 
 ```bash
-# Supervised (recommended when you have incidents):
+# Supervised — labeled in `dtk tune`: just run it, autotune auto-discovers
+# the newest file in incidents/<name>/ (no --incidents flag needed):
+dtk autotune --select <name>
+
+# Supervised — point at a specific labels file or set explicitly:
 dtk autotune --select <name> --incidents incidents/<name>.yml
 
-# Unsupervised (no labels — tunes on data statistics):
+# Unsupervised (no labels anywhere — tunes on data statistics):
 dtk autotune --select <name>
 ```
 

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/cli/assets/claude/skills/dtk-setup-project/SKILL.md

@@ -45,7 +45,8 @@ side by side, ask which one to set up.
 > a database MCP): you can inspect metric series, find incidents to label for
 > `dtk autotune`, sanity-check queries, and confirm detections yourself. Suggest
 > the user connect one if they haven't; if they can't, you can still do
-> everything by asking them to run queries and by using `dtk autotune --label`.
+> everything by asking them to run queries and by marking incidents visually in
+> `dtk tune` (Label/Review modes), which `dtk autotune` auto-discovers.
 
 ## Step 1 — Pick the database backend
 

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/cli/commands/autotune.py

@@ -24,16 +24,11 @@ from detectkit.autotune import (
     compute_run_id,
     emit_tuned_config,
     parse_labels_file,
-    render_labeler_html,
     run_autotune_engine,
 )
-from detectkit.autotune.label_server import serve_labeler
 from detectkit.autotune.labels import (
     GroundTruth,
     IncidentLabels,
-    incidents_to_display,
-    load_capture_windows,
-    load_incidents_for_display,
     parse_incident_labels,
 )
 from detectkit.cli._output import echo_done, echo_error, echo_noop
@@ -107,9 +102,10 @@ _LABELS_GLOBS = ("*.yml", "*.yaml", "*.json")
 def _labels_files(directory: Path) -> list[Path]:
     """All labels files in *directory*, oldest→newest.
 
-    The labeler saves versioned, ISO-stamped names (``<metric>[-<set>]-<UTC>.yml``)
-    which sort chronologically, so name order is chronological (tie-broken by mtime).
-    This lets ``incidents/<metric>/`` keep every labeling round on disk.
+    ``dtk tune`` (Label mode) saves versioned, ISO-stamped names
+    (``<metric>[-<set>]-<UTC>.yml``) which sort chronologically, so name order is
+    chronological (tie-broken by mtime). This lets ``incidents/<metric>/`` keep
+    every labeling round on disk.
     """
     files: list[Path] = []
     for pattern in _LABELS_GLOBS:
@@ -117,64 +113,6 @@ def _labels_files(directory: Path) -> list[Path]:
     return sorted(files, key=lambda p: (p.name, p.stat().st_mtime))
 
 
-def _resolve_preload_incidents(
-    *,
-    metric: str,
-    interval_seconds: int,
-    incidents_path: str | None,
-    autotune_cfg: AutoTuneConfig,
-    project_root: Path,
-) -> tuple[list[dict[str, str]], Path | None]:
-    """Existing incidents to seed the labeler with (edit-in-place flow).
-
-    Tries, in order: the ``--incidents`` flag, the config ``labels_file``, then the
-    default versioned dir ``incidents/<metric>/`` (where ``--label`` saves). A
-    directory resolves to its newest file. Best-effort — a missing/invalid file
-    just yields an empty seed (and a warning), never aborting the labeling flow.
-    """
-    candidates: list[Path] = []
-    explicit = incidents_path or autotune_cfg.labels_file
-    if explicit:
-        p = Path(explicit)
-        candidates.append(p if p.is_absolute() else project_root / p)
-    candidates.append(project_root / "incidents" / metric)
-    for cand in candidates:
-        try:
-            if cand.is_dir():
-                files = _labels_files(cand)
-                if not files:
-                    continue
-                target = files[-1]
-            elif cand.exists():
-                target = cand
-            else:
-                continue
-            disp = load_incidents_for_display(
-                target, interval_seconds=interval_seconds, metric_name=metric
-            )
-            return disp, target
-        except Exception as exc:  # noqa: BLE001 — preload is a best-effort convenience
-            click.echo(click.style(f"  Could not preload {cand}: {exc}", fg="yellow"))
-            return [], None
-
-    # No file on disk — fall back to inline config incidents (mirrors the
-    # precedence in _resolve_labels) so an inline-labeled metric also seeds.
-    if autotune_cfg.incidents:
-        try:
-            labels = parse_incident_labels(
-                {
-                    "incidents": autotune_cfg.incidents,
-                    "timezone": autotune_cfg.incidents_timezone,
-                },
-                interval_seconds=interval_seconds,
-                metric_name=metric,
-            )
-            return incidents_to_display(labels), None
-        except Exception as exc:  # noqa: BLE001 — best-effort convenience
-            click.echo(click.style(f"  Could not preload inline incidents: {exc}", fg="yellow"))
-    return [], None
-
-
 def _pick_labels_file(files: list[Path]) -> tuple[Path, str]:
     """Choose one labels file from a versioned set; prompt when interactive."""
     newest = files[-1]
@@ -198,8 +136,9 @@ def _resolve_labels(
     """Resolve labels by precedence.
 
     ``--incidents`` flag > config ``labels_file`` > config inline ``incidents`` >
-    interactive prompt > none (unsupervised). A directory may be given for the
-    flag or ``labels_file``; its newest versioned file is used.
+    auto-discovered ``incidents/<metric>/`` (where ``dtk tune`` Label mode saves) >
+    interactive prompt > none (unsupervised). A directory may be given for the flag
+    or ``labels_file``; its newest versioned file is used.
     """
     path = incidents_path or autotune_cfg.labels_file
     if path:
@@ -231,6 +170,23 @@ def _resolve_labels(
         n = len(autotune_cfg.incidents)
         return labels, f"inline config ({n} incident{'s' if n != 1 else ''})"
 
+    # Auto-discover the metric's saved labels — `dtk tune` (Label mode) writes
+    # versioned files into incidents/<metric>/, so a labeling round there feeds the
+    # next autotune with no extra flags (newest used; interactive runs may pick).
+    default_dir = project_root / "incidents" / metric_name
+    if default_dir.is_dir():
+        files = _labels_files(default_dir)
+        if files:
+            chosen, how = _pick_labels_file(files)
+            labels = parse_labels_file(
+                chosen, interval_seconds=interval_seconds, metric_name=metric_name
+            )
+            try:
+                where: object = default_dir.relative_to(project_root)
+            except ValueError:
+                where = default_dir
+            return labels, f"file {chosen} (auto-discovered, {how} in {where}/)"
+
     if sys.stdin.isatty():
         return _prompt_labels(interval_seconds=interval_seconds), "interactive"
 
@@ -324,9 +280,6 @@ def run_autotune(
     *,
     select: str,
     incidents_path: str | None,
-    label: bool,
-    no_serve: bool = False,
-    no_open: bool = False,
     scoring_override: str | None,
     from_date: str | None,
     to_date: str | None,
@@ -363,9 +316,6 @@ def run_autotune(
             project_root=project_root,
             internal_manager=internal_manager,
             incidents_path=incidents_path,
-            label=label,
-            no_serve=no_serve,
-            no_open=no_open,
             scoring_override=scoring_override,
             from_dt=from_dt,
             to_dt=to_dt,
@@ -387,9 +337,6 @@ def _tune_one(
     project_root: Path,
     internal_manager: InternalTablesManager,
     incidents_path: str | None,
-    label: bool,
-    no_serve: bool = False,
-    no_open: bool = False,
     scoring_override: str | None,
     from_dt: datetime | None,
     to_dt: datetime | None,
@@ -413,70 +360,6 @@ def _tune_one(
         echo_noop(name, "no datapoints — run `dtk run --select " + name + " --steps load` first")
         return False
 
-    # --label: open the interactive labeler. Default — a local server that saves the
-    # marked incidents straight into incidents/<name>/ and then falls through to
-    # tuning on them. --no-serve instead writes a static HTML file and exits (you
-    # move the downloaded export in yourself); --no-open skips launching a browser.
-    if label:
-        click.echo(click.style(f"Processing metric: {name}", fg="cyan", bold=True))
-        preload, preload_src = _resolve_preload_incidents(
-            metric=name,
-            interval_seconds=interval_seconds,
-            incidents_path=incidents_path,
-            autotune_cfg=autotune_cfg,
-            project_root=project_root,
-        )
-        if preload:
-            if preload_src is None:
-                where: object = "inline config"
-            else:
-                try:
-                    where = preload_src.relative_to(project_root)
-                except ValueError:  # an absolute path outside the project tree
-                    where = preload_src
-            click.echo(f"  Editing {len(preload)} existing incident(s) from {where}")
-        # Restore the painted threshold-capture window from the same seed file
-        # (best-effort — a missing/old file just yields no window).
-        capture_windows: list[dict[str, str]] = []
-        if preload_src is not None:
-            try:
-                capture_windows = load_capture_windows(
-                    preload_src, interval_seconds=interval_seconds, metric_name=name
-                )
-            except Exception:  # noqa: BLE001 — restoring the scope is a convenience
-                capture_windows = []
-        if no_serve:
-            html = render_labeler_html(
-                name,
-                data,
-                interval_seconds=interval_seconds,
-                incidents=preload,
-                capture_windows=capture_windows,
-            )
-            out = project_root / "metrics" / f"{metric_path.stem}__labeler.html"
-            out.write_text(html, encoding="utf-8")
-            click.echo(f"  Wrote labeler: {out.relative_to(project_root)}")
-            click.echo(
-                f"  Open it, mark incidents, Export, save into incidents/{name}/, "
-                f"then re-run with --incidents incidents/{name}/"
-            )
-            return True
-        saved = serve_labeler(
-            metric_name=name,
-            data=data,
-            incidents_dir=project_root / "incidents" / name,
-            interval_seconds=interval_seconds,
-            open_browser=not no_open,
-            echo=click.echo,
-            preload=preload,
-            capture_windows=capture_windows,
-        )
-        if saved is None:
-            echo_noop(name, "labeling cancelled — no labels saved")
-            return False
-        click.echo(f"  Saved labels: {saved.relative_to(project_root)}")
-        incidents_path = str(saved)  # continue into supervised tuning on this set
-
     click.echo(click.style(f"Tuning metric: {name}", fg="cyan", bold=True))
     click.echo(f"  Config file: {metric_path.relative_to(project_root)}")
 

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/cli/commands/init.py

@@ -152,8 +152,9 @@ _EXAMPLE_INCIDENTS = """# Example incidents (labels) file for supervised `dtk au
 # - `label` is optional free text (documentation only).
 #
 # Tip: can't list incidents from memory? Run
-#   dtk autotune --select example_cpu_usage --label
-# to get a clickable HTML chart; mark incidents in a browser and export this file.
+#   dtk tune --select example_cpu_usage
+# and use Label mode to mark incidents in a browser; Save incidents writes them
+# into incidents/example_cpu_usage/, which `dtk autotune` auto-discovers.
 
 # Optional — must match the metric `name:` it labels (autotune refuses a mismatch).
 metric: example_cpu_usage

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/cli/main.py

@@ -214,22 +214,7 @@ def run(
     "--incidents",
     "incidents_path",
     type=click.Path(),
-    help="Canonical labels file marking real incidents (enables supervised tuning)",
-)
-@click.option(
-    "--label",
-    is_flag=True,
-    help="Open the interactive labeler (local server) to mark incidents, then tune on them",
-)
-@click.option(
-    "--no-serve",
-    is_flag=True,
-    help="With --label, write a static HTML labeler file and exit instead of serving",
-)
-@click.option(
-    "--no-open",
-    is_flag=True,
-    help="With --label, don't auto-open the browser (just print the local URL)",
+    help="Canonical labels file (or incidents/<metric>/ dir) marking real incidents",
 )
 @click.option(
     "--scoring",
@@ -275,9 +260,6 @@ def run(
 def autotune(
     select: str,
     incidents_path: str,
-    label: bool,
-    no_serve: bool,
-    no_open: bool,
     scoring_override: str,
     from_date: str,
     to_date: str,
@@ -295,19 +277,18 @@ def autotune(
     tuned config named <metric>__tuned_<id>. Each run is recorded in
     _dtk_autotune_runs.
 
-    Mark real incidents for supervised tuning via --incidents (a labels file);
-    without it, tuning falls back to an unsupervised objective.
+    Mark real incidents for supervised tuning via --incidents (a labels file or
+    the incidents/<metric>/ dir); without it, tuning falls back to an unsupervised
+    objective. Incidents marked in `dtk tune` (Label mode) are auto-discovered from
+    incidents/<metric>/, so no flag is needed after labeling there.
 
     Examples:
         # Supervised tuning against labeled incidents
         dtk autotune --select checkout_errors --incidents incidents/checkout.yml
 
-        # Unsupervised (no labels)
+        # Unsupervised (no labels), or auto-pick incidents/checkout_errors/ if present
         dtk autotune --select checkout_errors
 
-        # Mark incidents in a browser, save into incidents/<m>/, and tune on them
-        dtk autotune --select checkout_errors --label
-
         # Search only, change nothing
         dtk autotune --select checkout_errors --dry-run
     """
@@ -316,9 +297,6 @@ def autotune(
     run_autotune(
         select=select,
         incidents_path=incidents_path,
-        label=label,
-        no_serve=no_serve,
-        no_open=no_open,
         scoring_override=scoring_override,
         from_date=from_date,
         to_date=to_date,

{detectkit-0.41.0 → detectkit-0.42.0}/detectkit/reporting/html_report.py

@@ -1,10 +1,11 @@
 """Render a report payload into a single self-contained HTML file.
 
-Same delivery model as ``autotune/html_labeler.py``: one HTML document with the
-renderer JS inlined (the pre-built ``assets/report.js`` bundle — one source
-shared with the website landing demo) and the data baked in as a JS literal. No
-CDN, no network, nothing leaves the browser. Placeholders are substituted with
-``str.replace`` (NOT ``.format``) so literal ``{}`` in the JS/CSS survive.
+The self-contained inline-bundle delivery model (shared with the ``dtk tune``
+page): one HTML document with the renderer JS inlined (the pre-built
+``assets/report.js`` bundle — one source shared with the website landing demo)
+and the data baked in as a JS literal. No CDN, no network, nothing leaves the
+browser. Placeholders are substituted with ``str.replace`` (NOT ``.format``) so
+literal ``{}`` in the JS/CSS survive.
 """
 
 from __future__ import annotations

{detectkit-0.41.0 → detectkit-0.42.0/detectkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.41.0
+Version: 0.42.0
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT