Error reports: send in dev with [DEV] tag forwarded to Discord

- Drop the `cfg!(debug_assertions)` half of the skip in `error_reporter::upload`. CI still skips so test runs don't pollute the live channel, but debug builds now upload normally — manual "Send error report" works in dev.
- Add `BuildMode` (`release`/`debug`) and a `buildMode` field on `BundleManifest`. Resolved at compile time from `cfg!(debug_assertions)` via `BuildMode::current()`. Tests cover serialization and the `current()` mapping.
- API server reads `meta.buildMode` and forwards it to Discord. The webhook embed title is prefixed `[DEV]` for debug-build reports so triage can tell dev runs apart from production traffic. Field is optional and defaults to `release` for older clients.
- Drop the dev-disable behavior on the Send button in `ErrorReportDialog.svelte`: removes the `sendDisabledInDev`/`sendTooltip` constants, the `use:tooltip` wrapper, the unused `tooltip` import, and the `&& !sendDisabledInDev` clause in `handleKeydown`.
- Revert the `vi.stubEnv('DEV', false)` plumbing in `ErrorReportDialog.a11y.test.ts` — no longer needed.
- Update `error_reporter/CLAUDE.md`: only CI is bypassed, document the new `buildMode` manifest field and what it's for.

Author: vdavid

apps/api-server/src/discord.test.ts

@@ -11,6 +11,7 @@ import {
 const baseNotification: ErrorReportNotification = {
   id: 'ERR-A2345',
   kind: 'user',
+  buildMode: 'release',
   appVersion: '0.13.0',
   osVersion: '15.3.1',
   arch: 'aarch64',
@@ -97,6 +98,18 @@ describe('buildErrorReportPayload', () => {
     }
     expect(payload.embeds[0].fields.find((f) => f.name === 'User note')).toBeUndefined()
   })
+
+  it('prefixes the title with [DEV] when buildMode is debug', () => {
+    const payload = buildErrorReportPayload({ ...baseNotification, buildMode: 'debug' }) as {
+      embeds: { title: string }[]
+    }
+    expect(payload.embeds[0].title).toBe('[DEV] Error report ERR-A2345')
+  })
+
+  it('does not prefix the title when buildMode is release', () => {
+    const payload = buildErrorReportPayload(baseNotification) as { embeds: { title: string }[] }
+    expect(payload.embeds[0].title).toBe('Error report ERR-A2345')
+  })
 })
 
 describe('buildEvictionPayload', () => {

apps/api-server/src/discord.ts

@@ -9,6 +9,13 @@
 export interface ErrorReportNotification {
   id: string
   kind: 'user' | 'auto'
+  /**
+   * Forwarded from the manifest. `'debug'` reports come from a dev build of the
+   * desktop app (`cfg!(debug_assertions)`), and we prefix the embed title with
+   * `[DEV]` so triage can tell them apart from production traffic at a glance.
+   * Defaults to `'release'` upstream when older clients don't set it.
+   */
+  buildMode: 'release' | 'debug'
   appVersion: string
   osVersion: string
   arch: string
@@ -60,10 +67,11 @@ export function buildErrorReportPayload(n: ErrorReportNotification): unknown {
     fields.push({ name: 'User note', value: truncatedNote })
   }
 
+  const titlePrefix = n.buildMode === 'debug' ? '[DEV] ' : ''
   return {
     embeds: [
       {
-        title: `Error report ${n.id}`,
+        title: `${titlePrefix}Error report ${n.id}`,
         color: ERROR_REPORT_EMBED_COLOR,
         fields,
       },

apps/api-server/src/error-report.ts

@@ -22,6 +22,14 @@ const DEFAULT_BUCKET_NAME = 'cmdr-error-reports'
 
 export interface ErrorReportMeta {
   kind: 'user' | 'auto'
+  /**
+   * Set by the desktop client from `cfg!(debug_assertions)`. `'debug'` reports
+   * come from a dev build of the app; the Discord notification gets a `[DEV]`
+   * prefix so triage can keep them apart from production traffic. Optional for
+   * backwards compatibility with older clients that didn't set it — unset is
+   * treated as `'release'`.
+   */
+  buildMode?: 'release' | 'debug'
   appVersion: string
   osVersion: string
   arch: string
@@ -38,6 +46,7 @@ function isValidMeta(value: unknown): value is ErrorReportMeta {
     if (typeof val !== 'string' || val.length === 0) return false
   }
   if (v['userNote'] !== undefined && typeof v['userNote'] !== 'string') return false
+  if (v['buildMode'] !== undefined && v['buildMode'] !== 'release' && v['buildMode'] !== 'debug') return false
   return true
 }
 
@@ -128,6 +137,7 @@ async function postUploadWork(
     await postErrorReportNotification(env.DISCORD_WEBHOOK_URL, {
       id: args.id,
       kind: args.meta.kind,
+      buildMode: args.meta.buildMode ?? 'release',
       appVersion: args.meta.appVersion,
       osVersion: args.meta.osVersion,
       arch: args.meta.arch,

apps/desktop/src-tauri/src/error_reporter/CLAUDE.md

@@ -27,6 +27,10 @@ Manifest fields (`BundleManifest`):
 - `id`: short ID (`ERR-XXXXX`) generated client-side. **Server may regenerate** — UI
   always shows the server's response ID, never the local one.
 - `kind`: `"user"` or `"auto"` (Phase 5).
+- `buildMode`: `"release"` or `"debug"`. Resolved at compile time from
+  `cfg!(debug_assertions)` via `BuildMode::current()`. Forwarded to the api server so the
+  Discord notification embed prefixes the title with `[DEV]` for debug-build reports —
+  triage can keep dev-run reports apart from real production traffic at a glance.
 - `appVersion`, `osVersion`, `arch`: build/platform identifiers.
 - `activeSettings`: settings snapshot via the `ResolvedSettings` struct — every field
   resolved to its effective value (`null` is never shipped). Includes `indexingEnabled`,
@@ -94,11 +98,17 @@ dialog. Re-building is cheap (the heavy work is reading + redacting log lines, w
 runs on the blocking pool either way), and the inputs are deterministic enough that the
 preview hash matches what'll be uploaded.
 
-## Dev/CI bypass
+## CI bypass
 
-[`upload`] checks `cfg!(debug_assertions) || std::env::var("CI").is_ok()`. In either
-case it returns the locally-generated ID without calling the network. Mirrors the crash
-reporter's bypass — same reasoning (no production data pollution from dev runs).
+[`upload`] checks `std::env::var("CI").is_ok()` and short-circuits on a hit, returning
+the locally-generated ID without calling the network. CI runs shouldn't pollute the
+live error-report channel even if a test triggers a report.
+
+Debug builds **do** upload — that's the point of "Send error report" working in dev. The
+manifest carries `buildMode: "debug"`, which the api server reads to prefix the Discord
+embed title with `[DEV]` so triage can separate dev-run reports from production traffic
+at a glance. (Pre-fix-* `upload()` skipped the network in `cfg!(debug_assertions)` too,
+which made dev-mode "Send report" silently no-op — confusing and unhelpful.)
 
 The dialog has an extra "Save bundle to disk (debug)" button in dev that calls
 `save_error_report_to_disk` instead, writing the zip to the app data dir for inspection.

apps/desktop/src-tauri/src/error_reporter/mod.rs

@@ -116,6 +116,27 @@ pub enum BundleKind {
     Auto,
 }
 
+/// Whether this bundle was built by a release or a debug build of the desktop app.
+/// Forwarded to the api server in the manifest so triage can tell dev-run reports
+/// (which the api server tags `[DEV]` in Discord) apart from production reports.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum BuildMode {
+    Release,
+    Debug,
+}
+
+impl BuildMode {
+    /// Resolved at compile time from `cfg!(debug_assertions)`.
+    pub fn current() -> Self {
+        if cfg!(debug_assertions) {
+            BuildMode::Debug
+        } else {
+            BuildMode::Release
+        }
+    }
+}
+
 /// Time filter applied when picking which log content to include.
 ///
 /// - `Last24Hours`: include log files whose mtime is within the last 24 hours. Used by
@@ -233,6 +254,9 @@ impl ResolvedSettings {
 pub struct BundleManifest {
     pub id: String,
     pub kind: BundleKind,
+    /// Release vs debug build of the desktop app. Lets the api server tag dev-run
+    /// reports so triage can keep them separate from production traffic.
+    pub build_mode: BuildMode,
     pub app_version: String,
     pub os_version: String,
     pub arch: String,
@@ -357,6 +381,7 @@ pub fn build_bundle<R: tauri::Runtime>(
     let manifest = BundleManifest {
         id: id.clone(),
         kind,
+        build_mode: BuildMode::current(),
         app_version: env!("CARGO_PKG_VERSION").to_string(),
         os_version: get_os_version(),
         arch: std::env::consts::ARCH.to_string(),
@@ -552,14 +577,17 @@ pub fn generate_short_id() -> String {
     out
 }
 
-/// POST the bundle to the ingestion server. In dev/CI this skips the network call and
-/// synthesizes a response using the locally generated ID.
+/// POST the bundle to the ingestion server. In CI this skips the network call and
+/// synthesizes a response using the locally generated ID — CI runs shouldn't pollute
+/// the live error-report channel even if a test triggers a report. Debug builds DO
+/// upload; the manifest's `buildMode: "debug"` field lets the server tag those
+/// reports `[DEV]` so triage can separate them from production traffic.
 pub async fn upload(zip_bytes: Vec<u8>, manifest: &BundleManifest, server_url: &str) -> Result<UploadResult, String> {
-    let should_skip = cfg!(debug_assertions) || std::env::var("CI").is_ok();
+    let should_skip = std::env::var("CI").is_ok();
     if should_skip {
         log::info!(
             target: "cmdr_lib::error_reporter",
-            "Skipping error report upload (dev mode or CI). Local ID: {}",
+            "Skipping error report upload (CI). Local ID: {}",
             manifest.id,
         );
         return Ok(UploadResult {

apps/desktop/src-tauri/src/error_reporter/tests.rs

@@ -7,6 +7,7 @@ fn sample_manifest() -> BundleManifest {
     BundleManifest {
         id: "ERR-AB23X".to_string(),
         kind: BundleKind::User,
+        build_mode: BuildMode::Release,
         app_version: "0.0.0-test".to_string(),
         os_version: "macOS test".to_string(),
         arch: "aarch64".to_string(),
@@ -134,6 +135,48 @@ fn redaction_is_applied_to_log_lines() {
     );
 }
 
+#[test]
+fn build_mode_serializes_lowercase() {
+    let release = serde_json::to_string(&BuildMode::Release).unwrap();
+    assert_eq!(release, "\"release\"");
+    let debug = serde_json::to_string(&BuildMode::Debug).unwrap();
+    assert_eq!(debug, "\"debug\"");
+}
+
+#[test]
+fn manifest_serializes_build_mode_with_camel_case_key() {
+    let now = SystemTime::now();
+    let manifest = sample_manifest();
+    let bytes = build_zip(&manifest, &BTreeMap::new(), now).unwrap();
+    let entries = read_zip_entries(&bytes);
+    let manifest_json = entries.get("manifest.json").unwrap();
+    assert!(
+        manifest_json.contains("\"buildMode\": \"release\""),
+        "expected `\"buildMode\": \"release\"` in manifest JSON, got: {manifest_json}",
+    );
+
+    // Debug build serializes to "debug".
+    let mut debug_manifest = sample_manifest();
+    debug_manifest.build_mode = BuildMode::Debug;
+    let bytes = build_zip(&debug_manifest, &BTreeMap::new(), now).unwrap();
+    let entries = read_zip_entries(&bytes);
+    let manifest_json = entries.get("manifest.json").unwrap();
+    assert!(
+        manifest_json.contains("\"buildMode\": \"debug\""),
+        "expected `\"buildMode\": \"debug\"` in manifest JSON, got: {manifest_json}",
+    );
+}
+
+#[test]
+fn build_mode_current_matches_cfg() {
+    let expected = if cfg!(debug_assertions) {
+        BuildMode::Debug
+    } else {
+        BuildMode::Release
+    };
+    assert_eq!(BuildMode::current(), expected);
+}
+
 #[test]
 fn short_id_matches_expected_format() {
     let re = regex::Regex::new("^ERR-[23456789ABCDEFGHJKMNPQRSTUVWXYZ]{5}$").unwrap();

apps/desktop/src/lib/error-reporter/ErrorReportDialog.a11y.test.ts

@@ -5,7 +5,7 @@
  * The `prepareErrorReportPreview` IPC is mocked so the test runs deterministically.
  */
 
-import { describe, it, vi, expect, beforeEach, afterEach } from 'vitest'
+import { describe, it, vi, expect, beforeEach } from 'vitest'
 import { mount, tick } from 'svelte'
 import ErrorReportDialog from './ErrorReportDialog.svelte'
 import { expectNoA11yViolations } from '$lib/test-a11y'
@@ -57,15 +57,6 @@ Object.defineProperty(navigator, 'clipboard', {
 describe('ErrorReportDialog', () => {
   beforeEach(() => {
     closeErrorReportDialog()
-    // Tests run in Vitest's `test` mode where `import.meta.env.DEV` is true
-    // by default. Pretend we're a release build so the dialog's dev-mode
-    // Send-disable doesn't shadow the assertions below — there's a separate
-    // test ("disables Send in dev builds") for the dev-disable behavior.
-    vi.stubEnv('DEV', false)
-  })
-
-  afterEach(() => {
-    vi.unstubAllEnvs()
   })
 
   it('default render has no a11y violations', async () => {

apps/desktop/src/lib/error-reporter/ErrorReportDialog.svelte

@@ -21,7 +21,6 @@
     import BundleSavedToastContent, { setLastSavedBundlePath } from './BundleSavedToastContent.svelte'
     import { closeErrorReportDialog, errorReportFlow } from './error-report-flow.svelte'
     import { getAppLogger } from '$lib/logging/logger'
-    import { tooltip } from '$lib/tooltip/tooltip'
 
     const log = getAppLogger('errorReportDialog')
 
@@ -123,16 +122,6 @@
         }
     }
 
-    // In dev / debug builds the backend's `upload()` function intentionally
-    // short-circuits before hitting the network (see `error_reporter::upload`),
-    // so clicking Send used to look like it succeeded but did nothing. Disable
-    // the button instead and explain via a tooltip — the Save-to-disk button
-    // is right next to it for inspecting the bundle locally.
-    const sendDisabledInDev = isDev
-    const sendTooltip = sendDisabledInDev
-        ? "Disabled in dev builds — uploads are skipped on purpose so dev runs don't pollute prod. Use 'Save bundle to disk' to inspect the report locally."
-        : undefined
-
     async function handleCopyId() {
         if (!preview) return
         await navigator.clipboard.writeText(preview.id)
@@ -146,13 +135,7 @@
 
     function handleKeydown(event: KeyboardEvent) {
         // Cmd/Ctrl+Enter sends. Plain Enter is consumed by the textarea.
-        if (
-            (event.metaKey || event.ctrlKey) &&
-            event.key === 'Enter' &&
-            !sending &&
-            !noteOverLimit &&
-            !sendDisabledInDev
-        ) {
+        if ((event.metaKey || event.ctrlKey) && event.key === 'Enter' && !sending && !noteOverLimit) {
             event.preventDefault()
             void handleSend()
         }
@@ -263,15 +246,13 @@
             {/if}
             <span class="spacer"></span>
             <Button variant="secondary" onclick={handleClose} disabled={sending}>Cancel</Button>
-            <span use:tooltip={sendTooltip}>
-                <Button
-                    variant="primary"
-                    onclick={() => void handleSend()}
-                    disabled={sending || noteOverLimit || preparing || sendDisabledInDev}
-                >
-                    {sending ? 'Sending…' : 'Send report'}
-                </Button>
-            </span>
+            <Button
+                variant="primary"
+                onclick={() => void handleSend()}
+                disabled={sending || noteOverLimit || preparing}
+            >
+                {sending ? 'Sending…' : 'Send report'}
+            </Button>
         </div>
     </div>
 </ModalDialog>