Which Telemetry Events Does Munder Difflin Collect and How to Opt Out

Munder Difflin collects only five anonymous telemetry events—first_run, app_launched, agent_spawned, feature_used, and session_ended—and users can disable them via the Settings UI, the DO_NOT_TRACK environment variable, or by building from source without a PostHog API key.

Munder Difflin, an open-source agentic coding environment maintained by chaitanyagiri/munder-difflin, implements a privacy-first analytics system that never transmits personally identifying information. All telemetry events are strictly allow-listed in src/main/analytics.ts and documented in the project's TELEMETRY.md contract. Understanding exactly what data leaves your machine and how to stop it ensures you maintain full control over your development workflow.

What Telemetry Events Munder Difflin Collects

The application records a minimal set of anonymous usage events to gauge feature adoption and session patterns. Every event shares three standard properties—app_version, os, and arch—and contains no file paths, transcript content, API keys, or user identifiers.

The Complete Event List

According to TELEMETRY.md, the analytics implementation tracks exactly five event types:

Event	Extra Property	Emission Trigger
first_run	—	Emitted once, the first time the application ever starts
app_launched	—	Emitted on every application startup
agent_spawned	provider (e.g., claude, codex)	Emitted when a new agent terminal spawns
feature_used	feature (e.g., slack_trigger, voice_dictation)	Emitted at most once per feature per session
session_ended	duration_bucket (<5m, 5-30m, 30m-2h, 2-8h, 8h+)	Emitted when the app quits, using coarse buckets

The session_ended event specifically buckets raw durations into coarse ranges before transmission, ensuring precise session length remains local to your machine.

How the Allow-List Enforces Privacy

In src/main/analytics.ts, the analytics client implements a strict allow-list filter. Any event not explicitly defined in the contract is dropped before reaching the outbound service. This hard constraint prevents accidental leakage of debug logs or unintended metadata.

How to Disable Munder Difflin Telemetry

The repository provides three independent opt-out mechanisms. Activating any one of them immediately disables all telemetry transmission.

Method 1: Toggle the Settings UI Switch

The most accessible method uses the Settings modal. Navigate to General > Anonymous usage stats and toggle the switch to off.

This action writes telemetryEnabled: false to the user configuration managed by src/main/config.ts. The renderer-side implementation in src/renderer/src/components/SettingsModal.tsx handles the state transition:

// In SettingsModal.tsx – the toggle handler
const toggleTelemetry = async () => {
  const next = !telemetryOn;          // flip UI state
  setTelemetryOn(next);               // optimistic UI update
  try {
    await window.cth.updateConfig({ telemetryEnabled: next });
  } catch {
    // revert UI on failure
    setTelemetryOn(!next);
  }
};

Method 2: Set the DO_NOT_TRACK Environment Variable

Before launching the application, set the DO_NOT_TRACK environment variable to any non-empty value other than 0. The check occurs in src/main/analytics.ts before the app reads its configuration file:

function dntSet(): boolean {
  const v = process.env.DO_NOT_TRACK;
  return v !== undefined && v !== '' && v !== '0';
}
// All tracking calls return early when dntSet() === true

To apply this on macOS or Linux:

export DO_NOT_TRACK=1
./MunderDifflin.app

On Windows PowerShell:

$env:DO_NOT_TRACK="1"
.\MunderDifflin.exe

Method 3: Build From Source Without Analytics

The PostHog API key (__POSTHOG_KEY__) is injected at build time. Compiling the application without providing this key results in a no-op analytics module. To create a telemetry-free binary:

# Clone the repo and build without injecting a PostHog key

git clone https://github.com/chaitanyagiri/munder-difflin.git
cd munder-difflin

# Ensure POSTHOG_KEY is empty or unset

export POSTHOG_KEY=
npm run build

This method is ideal for enterprise deployments or privacy-sensitive environments requiring absolute assurance that no network calls to analytics endpoints can occur.

Programmatic Disabling (Runtime)

For extension developers or power users, the main process exposes a direct API to toggle telemetry at runtime:

import { analytics } from './analytics';

// Turn telemetry off for the current runtime
analytics.setEnabled(false);

This is useful when scripting application behavior or building custom wrappers, though the change persists only for the current session unless paired with a configuration update.

Summary

• Five events only: Munder Difflin sends first_run, app_launched, agent_spawned, feature_used, and session_ended, each stripped of PII and file paths.
• Allow-listed enforcement: src/main/analytics.ts drops any event not explicitly defined in TELEMETRY.md.
• Three opt-out paths: Disable via Settings UI (persists to src/main/config.ts), set DO_NOT_TRACK=1, or build from source without POSTHOG_KEY.
• No fine-grained control: Opting out disables the entire analytics pipeline; there is no mechanism to selectively allow specific events while blocking others.

Frequently Asked Questions

Does Munder Difflin collect personal information?

No. According to the source code in src/main/analytics.ts and the TELEMETRY.md contract, events contain only app_version, os, arch, and event-specific enums or coarse duration buckets. The system explicitly excludes usernames, repository paths, API keys, and code content from transmission.

Can I verify that telemetry is actually disabled?

Yes. If you use the DO_NOT_TRACK environment variable, the dntSet() function in src/main/analytics.ts returns true and blocks all tracking calls before they execute. When building from source without POSTHOG_KEY, the analytics module compiles to a no-op, ensuring no outbound network requests to PostHog endpoints. You can confirm this by monitoring network traffic or by checking that analytics.setEnabled(false) reflects in the internal state.

Will disabling telemetry affect application functionality?

No. The telemetry system is strictly passive collection. Opting out via the Settings UI, environment variable, or source build removal does not disable agent spawning, feature flags, or any core IDE functionality. The application degrades gracefully by simply skipping the analytics emission logic.

What happens if I disable telemetry after the app has already sent some events?

Events are transmitted in real-time or near-real-time at session boundaries. Disabling telemetry via the Settings UI stops future emissions immediately, but events already dispatched to PostHog prior to the toggle cannot be retracted by the client. To prevent any transmission from the first launch, set DO_NOT_TRACK=1 before starting the application for the first time.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}