chati-dev 3.3.0 → 3.3.2

package/TERMS_OF_USE.md

@@ -0,0 +1,56 @@
+# Chati.dev Terms of Use
+
+Last updated: 2026-03-03
+
+## 1. Acceptance
+
+By installing and using Chati.dev, you agree to these Terms of Use.
+
+## 2. Anonymous Usage Data Collection
+
+Chati.dev collects anonymous usage data by default to improve the product. This includes:
+
+- **Agents used** — which pipeline agents are invoked (e.g., brief, architect, dev)
+- **Pipeline duration** — how long each pipeline phase takes
+- **Gate scores** — quality gate evaluation scores
+- **Circuit breaker events** — when safety mechanisms are triggered
+- **Error types** — categorized error codes (no stack traces or file paths)
+
+### What is NOT collected
+
+- No source code, file contents, or file paths
+- No personal information (name, email, IP address)
+- No project names or repository URLs
+- No prompts, conversations, or AI responses
+
+### Anonymous Identification
+
+A random UUID is generated locally for your installation. This ID cannot be traced back to you.
+
+## 3. Opting Out
+
+You can disable telemetry at any time:
+
+```
+npx chati-dev telemetry disable
+```
+
+You can re-enable it with:
+
+```
+npx chati-dev telemetry enable
+```
+
+Check current status:
+
+```
+npx chati-dev telemetry
+```
+
+## 4. Data Handling
+
+Data is sent to Chati.dev telemetry servers and used solely for product improvement. Data is not sold or shared with third parties.
+
+## 5. License
+
+Chati.dev is licensed under the Elastic License 2.0. See LICENSE for full terms.

package/framework/config.yaml

@@ -1,8 +1,8 @@
 # chati.dev Configuration
-version: "3.3.0"
+version: "3.3.2"
 installed_at: "2026-02-07T10:00:00Z"
-updated_at: "2026-03-02T00:00:00Z"
-installer_version: "3.3.0"
+updated_at: "2026-03-03T00:00:00Z"
+installer_version: "3.3.2"
 project_type: greenfield
 language: en
 ides: [claude-code]
@@ -27,3 +27,8 @@ providers:
 #   brownfield-wu:
 #     provider: gemini
 #     model: pro
+
+# Telemetry — opt-in anonymous usage tracking
+telemetry:
+  enabled: true
+  anonymous_id: d0ae24af-0a62-472c-b501-2104f03aa6af

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chati-dev",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "AI-Powered Multi-Agent Orchestration System — Structured vibe coding for Full Stack Development",
   "type": "module",
   "bin": {
@@ -21,7 +21,8 @@
     "assets/",
     "framework/",
     "scripts/",
-    "LICENSE"
+    "LICENSE",
+    "TERMS_OF_USE.md"
   ],
   "scripts": {
     "start": "node bin/chati.js",

package/src/installer/templates.js

@@ -110,7 +110,7 @@ export function generateConfigYaml(config) {
 
   // Add telemetry config
   configData.telemetry = {
-    enabled: config.telemetryEnabled || false,
+    enabled: config.telemetryEnabled !== false,
     anonymous_id: null,
   };
 

package/src/orchestrator/pipeline-manager.js

@@ -5,9 +5,10 @@
 
 import { AGENT_PIPELINE, getNextAgent } from './agent-selector.js';
 import { calculateBracket, estimateRemaining } from '../context/bracket-tracker.js';
-import { track as telemetryTrack, flush as telemetryFlush } from '../telemetry/collector.js';
+import { initCollector, track as telemetryTrack, flush as telemetryFlush } from '../telemetry/collector.js';
 import { sendEvents } from '../telemetry/sender.js';
-import { getTelemetryConfig } from '../telemetry/config.js';
+import { getTelemetryConfig, isEnabled as isTelemetryEnabled } from '../telemetry/config.js';
+import { getCurrentVersion } from '../upgrade/checker.js';
 
 /**
  * Pipeline phases in order.
@@ -39,7 +40,7 @@ const QA_IMPLEMENTATION_THRESHOLD = 95;
  * @returns {object} Pipeline state
  */
 export function initPipeline(options = {}) {
-  const { isGreenfield = true, mode = 'discover' } = options;
+  const { isGreenfield = true, mode = 'discover', targetDir } = options;
 
   const agents = {};
   for (const agentDef of AGENT_PIPELINE) {
@@ -61,9 +62,25 @@ export function initPipeline(options = {}) {
     };
   }
 
+  const resolvedDir = targetDir || process.cwd();
+
+  // Initialize telemetry collector based on project config
+  initCollector(isTelemetryEnabled(resolvedDir));
+
+  const sessionId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+  telemetryTrack('session_started', {
+    sessionId,
+    pipelineType: 'full',
+    mode,
+  });
+
   return {
     phase: mode,
     isGreenfield,
+    sessionId,
+    targetDir: resolvedDir,
+    chatiVersion: getCurrentVersion(resolvedDir) || 'unknown',
     startedAt: new Date().toISOString(),
     completedAt: null,
     agents,
@@ -96,7 +113,7 @@ const QUICK_FLOW_AGENTS = ['brief', 'dev', 'qa-implementation', 'devops'];
  * @returns {object} Pipeline state
  */
 export function initQuickFlowPipeline(options = {}) {
-  const { isGreenfield = false, mode = 'discover' } = options;
+  const { isGreenfield = false, mode = 'discover', targetDir } = options;
 
   const agents = {};
   for (const agentName of QUICK_FLOW_AGENTS) {
@@ -108,10 +125,26 @@ export function initQuickFlowPipeline(options = {}) {
     };
   }
 
+  const resolvedDir = targetDir || process.cwd();
+
+  // Initialize telemetry collector based on project config
+  initCollector(isTelemetryEnabled(resolvedDir));
+
+  const sessionId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+  telemetryTrack('session_started', {
+    sessionId,
+    pipelineType: 'quick-flow',
+    mode,
+  });
+
   return {
     phase: mode,
     isGreenfield,
     isQuickFlow: true,
+    sessionId,
+    targetDir: resolvedDir,
+    chatiVersion: getCurrentVersion(resolvedDir) || 'unknown',
     startedAt: new Date().toISOString(),
     completedAt: null,
     agents,
@@ -130,7 +163,7 @@ export function initQuickFlowPipeline(options = {}) {
  * @returns {object} Pipeline state
  */
 export function initStandardFlowPipeline(options = {}) {
-  const { isGreenfield = false, mode = 'discover' } = options;
+  const { isGreenfield = false, mode = 'discover', targetDir } = options;
 
   const agents = {};
   for (const agentName of STANDARD_FLOW_AGENTS) {
@@ -142,10 +175,26 @@ export function initStandardFlowPipeline(options = {}) {
     };
   }
 
+  const resolvedDir = targetDir || process.cwd();
+
+  // Initialize telemetry collector based on project config
+  initCollector(isTelemetryEnabled(resolvedDir));
+
+  const sessionId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+  telemetryTrack('session_started', {
+    sessionId,
+    pipelineType: 'standard',
+    mode,
+  });
+
   return {
     phase: mode,
     isGreenfield,
     isStandardFlow: true,
+    sessionId,
+    targetDir: resolvedDir,
+    chatiVersion: getCurrentVersion(resolvedDir) || 'unknown',
     startedAt: new Date().toISOString(),
     completedAt: null,
     agents,
@@ -245,13 +294,24 @@ export function advancePipeline(pipelineState, completedAgent, results = {}) {
 
       // Pipeline complete
       newState.completedAt = new Date().toISOString();
+      const pipelineType1 = newState.isQuickFlow ? 'quick-flow' : newState.isStandardFlow ? 'standard' : 'full';
+      const totalDuration1 = Date.now() - new Date(newState.startedAt).getTime();
       telemetryTrack('pipeline_completed', {
-        pipelineType: newState.isQuickFlow ? 'quick-flow' : newState.isStandardFlow ? 'standard' : 'full',
-        totalDuration: Date.now() - new Date(newState.startedAt).getTime(),
+        pipelineType: pipelineType1,
+        totalDuration: totalDuration1,
         agentsRun: newState.completedAgents.length,
         finalStatus: 'completed',
         deviationCount: (newState.modeTransitions || []).length,
       });
+      telemetryTrack('session_completed', {
+        sessionId: newState.sessionId || 'unknown',
+        pipelineType: pipelineType1,
+        mode: newState.phase === 'deploy' ? 'deploy' : 'build',
+        finalStage: newState.phase,
+        duration: totalDuration1,
+        agentCount: newState.completedAgents.length,
+        success: true,
+      });
       const flushedEvents = telemetryFlush();
       if (flushedEvents.length > 0) {
         const tConfig = getTelemetryConfig(newState.targetDir || process.cwd());
@@ -306,13 +366,24 @@ export function advancePipeline(pipelineState, completedAgent, results = {}) {
 
     // Pipeline complete
     newState.completedAt = new Date().toISOString();
+    const pipelineType2 = newState.isQuickFlow ? 'quick-flow' : newState.isStandardFlow ? 'standard' : 'full';
+    const totalDuration2 = Date.now() - new Date(newState.startedAt).getTime();
     telemetryTrack('pipeline_completed', {
-      pipelineType: newState.isQuickFlow ? 'quick-flow' : newState.isStandardFlow ? 'standard' : 'full',
-      totalDuration: Date.now() - new Date(newState.startedAt).getTime(),
+      pipelineType: pipelineType2,
+      totalDuration: totalDuration2,
       agentsRun: newState.completedAgents.length,
       finalStatus: 'completed',
       deviationCount: (newState.modeTransitions || []).length,
     });
+    telemetryTrack('session_completed', {
+      sessionId: newState.sessionId || 'unknown',
+      pipelineType: pipelineType2,
+      mode: newState.phase === 'deploy' ? 'deploy' : 'build',
+      finalStage: newState.phase,
+      duration: totalDuration2,
+      agentCount: newState.completedAgents.length,
+      success: true,
+    });
     const flushedEvents2 = telemetryFlush();
     if (flushedEvents2.length > 0) {
       const tConfig2 = getTelemetryConfig(newState.targetDir || process.cwd());

package/src/quality/test-runner.js

@@ -136,8 +136,7 @@ export function runTests(projectDir, options = {}) {
   }
 
   const start = Date.now();
-  let rawOutput = '';
-  let exitCode = 0;
+  let rawOutput, exitCode;
 
   try {
     rawOutput = execSync(command, {
@@ -146,6 +145,7 @@ export function runTests(projectDir, options = {}) {
       timeout,
       stdio: ['pipe', 'pipe', 'pipe'],
     });
+    exitCode = 0;
   } catch (err) {
     exitCode = err.status || 1;
     rawOutput = (err.stdout || '') + (err.stderr || '');
@@ -208,8 +208,7 @@ export function runLint(projectDir, options = {}) {
     return { success: true, errors: 0, warnings: 0, rawOutput: 'No lint command detected' };
   }
 
-  let rawOutput = '';
-  let exitCode = 0;
+  let rawOutput, exitCode;
 
   try {
     rawOutput = execSync(command, {
@@ -218,6 +217,7 @@ export function runLint(projectDir, options = {}) {
       timeout,
       stdio: ['pipe', 'pipe', 'pipe'],
     });
+    exitCode = 0;
   } catch (err) {
     exitCode = err.status || 1;
     rawOutput = (err.stdout || '') + (err.stderr || '');

package/src/telemetry/config.js

@@ -24,7 +24,7 @@ export function getTelemetryConfig(targetDir) {
   const configPath = join(targetDir, 'chati.dev', 'config.yaml');
 
   const defaults = {
-    enabled: false,
+    enabled: true,
     anonymousId: null,
     endpoint: 'https://chati-telemetry.vercel.app/api/events',
     apiKey: '10b0b54ba4f392fa46379ba778062ab0af5ca61e79609a7dce4aadd660104b56',

package/src/telemetry/index.js

@@ -5,7 +5,7 @@
  * All telemetry is opt-in and anonymous.
  */
 
-export { TELEMETRY_EVENTS, validateEvent } from './schema.js';
+export { TELEMETRY_EVENTS, validateEvent, EVENT_PROPERTY_RULES } from './schema.js';
 export { getTelemetryConfig, isEnabled, setEnabled, getAnonymousId } from './config.js';
 export { initCollector, track, flush, getBufferSize, getStatus } from './collector.js';
 export { sendEvents, DEFAULT_ENDPOINT } from './sender.js';

package/src/telemetry/schema.js

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Telemetry event schema and validation.
  *
- * Defines the 6 event types collected by opt-in telemetry.
+ * Defines the 9 event types collected by telemetry.
  * Zero PII — only anonymous usage metrics.
  */
 
@@ -16,6 +16,9 @@ export const TELEMETRY_EVENTS = [
   'pipeline_completed',
   'circuit_breaker_triggered',
   'error_occurred',
+  'session_started',
+  'session_completed',
+  'token_usage',
 ];
 
 // ---------------------------------------------------------------------------
@@ -44,18 +47,48 @@ const EVENT_PROPERTIES = {
   error_occurred: [
     'errorType', 'agent', 'provider', 'phase',
   ],
+  session_started: [
+    'sessionId', 'pipelineType', 'mode',
+  ],
+  session_completed: [
+    'sessionId', 'pipelineType', 'mode', 'finalStage',
+    'duration', 'agentCount', 'success',
+  ],
+  token_usage: [
+    'sessionId', 'agent', 'provider', 'model',
+    'inputTokens', 'outputTokens', 'totalTokens', 'estimatedCostUsd',
+  ],
 };
 
 // ---------------------------------------------------------------------------
-// PII blocklist — fields that MUST NEVER appear in telemetry
+// Property Rules (required fields + numeric validation for structured types)
 // ---------------------------------------------------------------------------
 
-const PII_BLOCKLIST = [
-  'path', 'filePath', 'fileName', 'directory', 'cwd',
-  'apiKey', 'token', 'secret', 'password', 'credential',
-  'email', 'username', 'name', 'ip', 'hostname',
-  'content', 'code', 'source', 'prompt', 'message',
-  'stackTrace', 'stack',
+export const EVENT_PROPERTY_RULES = {
+  session_started: {
+    required: ['sessionId', 'pipelineType', 'mode'],
+  },
+  session_completed: {
+    required: ['sessionId', 'pipelineType', 'mode', 'finalStage', 'duration', 'agentCount', 'success'],
+    numeric: ['duration', 'agentCount'],
+  },
+  token_usage: {
+    required: ['sessionId', 'agent', 'provider', 'model', 'inputTokens', 'outputTokens', 'totalTokens', 'estimatedCostUsd'],
+    numeric: ['inputTokens', 'outputTokens', 'totalTokens', 'estimatedCostUsd'],
+  },
+};
+
+// ---------------------------------------------------------------------------
+// PII patterns — fields that MUST NEVER appear in telemetry
+// Regex patterns aligned with chati-telemetry backend (case-insensitive)
+// ---------------------------------------------------------------------------
+
+const PII_PATTERNS = [
+  /^(file_?)?path$/i, /^file_?name$/i, /^dir(ectory)?$/i, /^cwd$/i,
+  /^api_?key$/i, /^(access_?)?token$/i, /^secret$/i, /^pass(word)?$/i,
+  /^cred(ential)?s?$/i, /^e?mail$/i, /^user_?name$/i, /^(full_?)?name$/i,
+  /^ip(_?addr(ess)?)?$/i, /^host_?name$/i, /^(source_?)?code$/i,
+  /^prompt$/i, /^message$/i, /^content$/i, /^stack_?trace$/i,
 ];
 
 // ---------------------------------------------------------------------------
@@ -81,9 +114,9 @@ export function validateEvent(event) {
 
   const props = event.properties || {};
 
-  // Check for PII fields
+  // Check for PII field names (regex-based, aligned with backend)
   for (const key of Object.keys(props)) {
-    if (PII_BLOCKLIST.includes(key)) {
+    if (PII_PATTERNS.some(pattern => pattern.test(key))) {
       errors.push(`PII field detected: "${key}" — must not be included in telemetry`);
     }
   }
@@ -91,7 +124,7 @@ export function validateEvent(event) {
   // Check for PII in values (paths, emails)
   for (const [key, value] of Object.entries(props)) {
     if (typeof value === 'string') {
-      if (value.includes('/Users/') || value.includes('/home/') || value.includes('C:\\Users\\')) {
+      if (/\/users\//i.test(value) || /\\users\\/i.test(value) || /\/home\//i.test(value)) {
         errors.push(`PII detected in "${key}": value contains filesystem path`);
       }
       if (value.includes('@') && value.includes('.')) {
@@ -100,5 +133,21 @@ export function validateEvent(event) {
     }
   }
 
+  // Property-level validation for event types with rules
+  const rules = EVENT_PROPERTY_RULES[event.type];
+  if (rules && props) {
+    const missing = rules.required.filter(key => !(key in props));
+    if (missing.length > 0) {
+      errors.push(`Missing required properties for "${event.type}": ${missing.join(', ')}`);
+    }
+    if (rules.numeric) {
+      for (const key of rules.numeric) {
+        if (key in props && (typeof props[key] !== 'number' || props[key] < 0)) {
+          errors.push(`Property "${key}" must be a non-negative number`);
+        }
+      }
+    }
+  }
+
   return { valid: errors.length === 0, errors };
 }

package/src/terminal/run-agent.js

@@ -18,7 +18,9 @@ import { buildAgentPrompt } from './prompt-builder.js';
 import { spawnTerminal } from './spawner.js';
 import { parseAgentOutput } from './handoff-parser.js';
 import { createCostTracker } from './cost-tracker.js';
-import { track as telemetryTrack } from '../telemetry/collector.js';
+import { initCollector, track as telemetryTrack, flush as telemetryFlush } from '../telemetry/collector.js';
+import { sendEvents } from '../telemetry/sender.js';
+import { getTelemetryConfig, isEnabled as isTelemetryEnabled } from '../telemetry/config.js';
 
 // ---------------------------------------------------------------------------
 // CLI argument parsing (no external deps)
@@ -62,6 +64,9 @@ async function main() {
   const projectDir = args['project-dir'] || process.cwd();
   const timeout = parseInt(args.timeout, 10) || 600_000; // default 10 minutes
 
+  // Initialize telemetry for this process
+  initCollector(isTelemetryEnabled(projectDir));
+
   // Load session state if available
   let sessionState = {};
   try {
@@ -117,6 +122,13 @@ async function main() {
   try {
     await waitForExit(handle, timeout);
   } catch (err) {
+    telemetryTrack('error_occurred', {
+      errorType: 'agent_failure',
+      agent: args.agent,
+      provider: promptResult.provider || args.provider || 'claude',
+      phase: sessionState?.phase || 'unknown',
+    });
+    await flushAndSend(projectDir);
     outputError(`Terminal execution failed: ${err.message}`);
     process.exit(2);
   }
@@ -156,6 +168,23 @@ async function main() {
     pipelineType: sessionState?.isQuickFlow ? 'quick-flow' : 'standard',
   });
 
+  // Track token usage if cost data is available
+  if (costRecord.inputTokens !== undefined) {
+    telemetryTrack('token_usage', {
+      sessionId: sessionState?.sessionId || 'unknown',
+      agent: args.agent,
+      provider: costRecord.provider,
+      model: costRecord.model || 'unknown',
+      inputTokens: costRecord.inputTokens || 0,
+      outputTokens: costRecord.outputTokens || 0,
+      totalTokens: (costRecord.inputTokens || 0) + (costRecord.outputTokens || 0),
+      estimatedCostUsd: costRecord.cost || 0,
+    });
+  }
+
+  // Flush telemetry before exit
+  await flushAndSend(projectDir);
+
   // Parse the handoff from stdout
   const parsed = parseAgentOutput(stdout);
 
@@ -193,6 +222,22 @@ async function main() {
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Flush buffered telemetry events and send to the backend.
+ * Fire-and-forget — never blocks process exit on failure.
+ */
+async function flushAndSend(projectDir) {
+  const events = telemetryFlush();
+  if (events.length === 0) return;
+
+  try {
+    const tConfig = getTelemetryConfig(projectDir);
+    await sendEvents(events, { ...tConfig, version: tConfig.chatiVersion || 'unknown' });
+  } catch {
+    // Silently fail — telemetry must never block agent execution
+  }
+}
+
 /**
  * Wait for a terminal handle's process to exit.
  */

package/src/wizard/i18n.js

@@ -66,9 +66,14 @@ const FALLBACK_EN = {
     quick_start_1: 'Open your IDE',
     quick_start_2: 'Type: /chati',
     quick_start_3: 'The orchestrator will guide you through the process',
-    telemetry_consent: 'Help improve Chati.dev by sharing anonymous usage data?',
-    telemetry_description: 'Anonymous metrics only (agents used, pipeline duration, gate scores). Zero code, files, or personal data. You can disable anytime with: npx chati-dev telemetry disable',
-    telemetry_privacy: 'Privacy: opt-in only, anonymous UUID, no PII collected.',
+    tos_title: 'Terms of Use',
+    tos_summary: 'By continuing, you accept the Chati.dev Terms of Use (see TERMS_OF_USE.md in the package).',
+    tos_telemetry_what: 'Chati.dev collects anonymous usage data: agents used, pipeline duration, gate scores. No code, files, or personal data is collected.',
+    tos_telemetry_optout: 'You can disable telemetry anytime with: npx chati-dev telemetry disable',
+    tos_accept: 'Do you accept the Terms of Use?',
+    tos_declined: 'Terms of Use declined. Installation cancelled.',
+    tos_telemetry_enabled: 'Telemetry: enabled (anonymous, opt-out — disable with: npx chati-dev telemetry disable)',
+    tos_telemetry_disabled: 'Telemetry: disabled',
   },
   agents: {
     starting: 'Starting agent: {agent}',

package/src/wizard/index.js

@@ -3,10 +3,13 @@ import { readFileSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { logBanner } from '../utils/logger.js';
-import { stepLanguage, stepProjectType, stepIDESelection, stepProviderSelection, stepEditorSelection, stepPrimaryProvider, stepConfirmation, stepTelemetryConsent } from './questions.js';
+import { stepLanguage, stepProjectType, stepProviderSelection, stepEditorSelection, stepPrimaryProvider, stepConfirmation, stepTermsOfUse } from './questions.js';
 import { createSpinner, showStep, showValidation, showQuickStart } from './feedback.js';
 import { installFramework } from '../installer/core.js';
 import { validateInstallation } from '../installer/validator.js';
+import { initCollector, track as telemetryTrack, flush as telemetryFlush } from '../telemetry/collector.js';
+import { sendEvents } from '../telemetry/sender.js';
+import { getTelemetryConfig } from '../telemetry/config.js';
 import { t } from './i18n.js';
 import { DEFAULT_MCPS } from '../config/mcp-configs.js';
 import { IDE_CONFIGS, IDE_TO_PROVIDER } from '../config/ide-configs.js';
@@ -33,7 +36,12 @@ export async function runWizard(targetDir, options = {}) {
 
   const language = options.language || await stepLanguage();
 
-  // Step 2: Project Type
+  // Step 2: Terms of Use (must accept to continue)
+  if (options.telemetry === undefined) {
+    await stepTermsOfUse();
+  }
+
+  // Step 3: Project Type
   const projectType = options.projectType || await stepProjectType(targetDir);
 
   // Step 3a: Provider Selection (which AI providers to use)
@@ -73,14 +81,15 @@ export async function runWizard(targetDir, options = {}) {
 
   await stepConfirmation(config);
 
-  // Step 5: Telemetry Consent (opt-in)
-  const telemetryEnabled = options.telemetry !== undefined ? options.telemetry : await stepTelemetryConsent();
-  config.telemetryEnabled = telemetryEnabled;
+  // Telemetry: enabled by default (opt-out model via ToS)
+  config.telemetryEnabled = options.telemetry !== undefined ? options.telemetry : true;
 
-  // Step 5: Installation + Validation
+  // Installation + Validation
   const primaryIDE = selectedIDEs.find(ide => IDE_TO_PROVIDER[ide] === primaryProvider) || selectedIDEs[0];
   const primaryIDEName = IDE_CONFIGS[primaryIDE]?.name || primaryIDE;
 
+  const installStart = Date.now();
+
   console.log();
   const installSpinner = createSpinner(t('installer.installing'));
   installSpinner.start();
@@ -112,9 +121,10 @@ export async function runWizard(targetDir, options = {}) {
     showStep(t('installer.created_memories'));
     showStep(t('installer.installed_intelligence'));
     showStep(`${t('installer.configured_mcps')} ${selectedMCPs.join(', ')}`);
-    if (telemetryEnabled) {
-      showStep('Telemetry: enabled (anonymous, opt-in)');
-    }
+    showStep(config.telemetryEnabled
+      ? t('installer.tos_telemetry_enabled')
+      : t('installer.tos_telemetry_disabled')
+    );
 
     // Validation
     console.log();
@@ -161,6 +171,22 @@ export async function runWizard(targetDir, options = {}) {
 
     showQuickStart(t('installer.quick_start_title'), quickStartSteps);
 
+    // Track installation telemetry
+    initCollector(config.telemetryEnabled);
+    telemetryTrack('installation_completed', {
+      providers: cliProviders,
+      editors: selectedEditors,
+      projectType,
+      language,
+      primaryProvider,
+      installDuration: Date.now() - installStart,
+    });
+    const installEvents = telemetryFlush();
+    if (installEvents.length > 0) {
+      const tConfig = getTelemetryConfig(targetDir);
+      sendEvents(installEvents, { ...tConfig, version: VERSION });
+    }
+
     return { success: true, config, validation };
   } catch (err) {
     installSpinner.stop();

package/src/wizard/questions.js

@@ -80,7 +80,7 @@ export async function stepProviderSelection() {
 
   for (const [key, config] of cliIDEs) {
     const provider = IDE_TO_PROVIDER[key];
-    let installed = false;
+    let installed;
     try {
       installed = provider ? await isProviderAvailable(provider) : false;
     } catch {
@@ -96,7 +96,7 @@ export async function stepProviderSelection() {
   }
 
   const selected = await p.multiselect({
-    message: t('installer.provider_selection_title'),
+    message: `${t('installer.provider_selection_title')} ${dim('(space to select, enter to confirm)')}`,
     options,
     required: true,
   });
@@ -127,7 +127,7 @@ export async function stepEditorSelection() {
   }));
 
   const selected = await p.multiselect({
-    message: t('installer.editor_selection_title'),
+    message: `${t('installer.editor_selection_title')} ${dim('(space to select, enter to confirm)')}`,
     options,
     required: false,
   });
@@ -187,7 +187,7 @@ export async function stepIDESelection() {
   }
 
   const selectedIDEs = await p.multiselect({
-    message: t('installer.ide_selection_title'),
+    message: `${t('installer.ide_selection_title')} ${dim('(space to select, enter to confirm)')}`,
     options,
     required: true,
   });
@@ -295,23 +295,32 @@ export async function stepConfirmation(config) {
 }
 
 /**
- * Step 5: Telemetry Consent (opt-in)
+ * Step: Terms of Use Acceptance
  *
- * Asks the user if they want to share anonymous usage metrics.
- * Returns true (opt-in) or false (opt-out).
+ * Shows Terms of Use that include telemetry data collection notice.
+ * User must accept to proceed. Declining aborts installation.
+ * Telemetry is enabled by default (opt-out model).
  */
-export async function stepTelemetryConsent() {
+export async function stepTermsOfUse() {
   p.note(
-    `${dim(t('installer.telemetry_description'))}\n\n${dim(t('installer.telemetry_privacy'))}`,
-    dim('Telemetry')
+    `${dim(t('installer.tos_summary'))}\n\n` +
+    `${dim(t('installer.tos_telemetry_what'))}\n\n` +
+    `${dim(t('installer.tos_telemetry_optout'))}`,
+    t('installer.tos_title')
   );
 
-  const consent = await p.confirm({
-    message: t('installer.telemetry_consent'),
-    initialValue: false,
+  const accepted = await p.confirm({
+    message: t('installer.tos_accept'),
+    initialValue: true,
   });
 
-  if (p.isCancel(consent)) return false;
+  if (p.isCancel(accepted) || !accepted) {
+    p.cancel(t('installer.tos_declined'));
+    process.exit(0);
+  }
 
-  return consent;
+  return true;
 }
+
+/** @deprecated Use stepTermsOfUse instead */
+export const stepTelemetryConsent = stepTermsOfUse;