copilot-tracer 1.0.4 → 1.0.6

package/dist/db.js

@@ -8,10 +8,20 @@ if (!fs.existsSync(DB_DIR))
     fs.mkdirSync(DB_DIR, { recursive: true });
 const db = new Database(DB_PATH);
 db.exec(`
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    path TEXT NOT NULL UNIQUE,
+    repo_url TEXT,
+    local_path TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
   CREATE TABLE IF NOT EXISTS sessions (
     id TEXT PRIMARY KEY,
     started_at TEXT NOT NULL,
-    ended_at TEXT
+    ended_at TEXT,
+    project_id TEXT REFERENCES projects(id)
   );
 
   CREATE TABLE IF NOT EXISTS traces (
@@ -38,8 +48,113 @@ db.exec(`
     FOREIGN KEY(session_id) REFERENCES sessions(id)
   );
 `);
-export function createSession(id) {
-    db.prepare('INSERT OR REPLACE INTO sessions (id, started_at) VALUES (?, ?)').run(id, new Date().toISOString());
+// Migrate existing DBs
+try {
+    db.prepare('ALTER TABLE projects ADD COLUMN repo_url TEXT').run();
+}
+catch { }
+try {
+    db.prepare('ALTER TABLE projects ADD COLUMN local_path TEXT').run();
+}
+catch { }
+try {
+    db.prepare('ALTER TABLE sessions ADD COLUMN project_id TEXT REFERENCES projects(id)').run();
+}
+catch { }
+export function ensureProject(projectPath, repoUrl) {
+    const id = 'project:' + projectPath;
+    const now = new Date().toISOString();
+    db.prepare('INSERT OR IGNORE INTO projects (id, path, repo_url, local_path, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)').run(id, projectPath, repoUrl ?? null, projectPath, now, now);
+    if (repoUrl) {
+        db.prepare('UPDATE projects SET repo_url = ?, updated_at = ? WHERE id = ?').run(repoUrl, now, id);
+    }
+    db.prepare('UPDATE projects SET updated_at = ? WHERE id = ?').run(now, id);
+    return id;
+}
+export function ensureProjectByRepo(repoUrl) {
+    // Try to find existing project by repo URL
+    const existing = db.prepare('SELECT id FROM projects WHERE repo_url = ?').get(repoUrl);
+    if (existing) {
+        db.prepare('UPDATE projects SET updated_at = ? WHERE id = ?').run(new Date().toISOString(), existing.id);
+        return existing.id;
+    }
+    // Create new project with repo URL as path (local_path set later)
+    const id = 'project:' + repoUrl;
+    const now = new Date().toISOString();
+    db.prepare('INSERT OR IGNORE INTO projects (id, path, repo_url, local_path, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)').run(id, repoUrl, repoUrl, null, now, now);
+    return id;
+}
+export function updateProjectLocalPath(projectId, localPath) {
+    db.prepare('UPDATE projects SET local_path = ?, updated_at = ? WHERE id = ?').run(localPath, new Date().toISOString(), projectId);
+}
+export function findProjectByRepo(repoUrl) {
+    const row = db.prepare('SELECT id, path, local_path FROM projects WHERE repo_url = ?').get(repoUrl);
+    return row ? { id: row.id, path: row.path, local_path: row.local_path } : null;
+}
+export function createSession(id, projectId) {
+    // Backfill-safe upsert: insert if missing, set project_id only when a project is
+    // provided AND the session currently has none (never null out an existing link).
+    db.prepare(`
+    INSERT INTO sessions (id, started_at, project_id) VALUES (?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      project_id = CASE
+        WHEN excluded.project_id IS NOT NULL THEN COALESCE(sessions.project_id, excluded.project_id)
+        ELSE sessions.project_id
+      END
+  `).run(id, new Date().toISOString(), projectId ?? null);
+}
+export function getDashboard() {
+    const projects = db.prepare(`
+    SELECT
+      p.id, p.path, p.repo_url, p.local_path,
+      COUNT(DISTINCT s.id) as session_count,
+      COALESCE(SUM(t.tokens_total), 0) as total_tokens,
+      COALESCE(SUM(t.ai_credits), 0) as total_credits,
+      MAX(s.started_at) as last_active_at
+    FROM projects p
+    LEFT JOIN sessions s ON s.project_id = p.id
+    LEFT JOIN traces t ON t.session_id = s.id
+    GROUP BY p.id
+    ORDER BY last_active_at DESC
+  `).all();
+    const totals = db.prepare(`
+    SELECT
+      (SELECT COUNT(*) FROM projects) as projects,
+      (SELECT COUNT(*) FROM sessions) as sessions,
+      COALESCE((SELECT SUM(tokens_total) FROM traces), 0) as tokens,
+      COALESCE((SELECT SUM(ai_credits) FROM traces), 0) as credits
+  `).get();
+    const enriched = projects.map(p => {
+        const lastSession = db.prepare(`
+      SELECT s.id,
+        COALESCE((SELECT SUM(tokens_total) FROM traces WHERE session_id = s.id), 0) as tokens,
+        COALESCE((SELECT SUM(ai_credits) FROM traces WHERE session_id = s.id), 0) as credits
+      FROM sessions s
+      WHERE s.project_id = ?
+      ORDER BY s.started_at DESC
+      LIMIT 1
+    `).get(p.id);
+        return {
+            id: p.id,
+            path: p.path,
+            repoUrl: p.repo_url,
+            localPath: p.local_path,
+            sessionCount: p.session_count || 0,
+            totalTokens: p.total_tokens || 0,
+            totalCredits: p.total_credits || 0,
+            lastActiveAt: p.last_active_at,
+            lastSession: lastSession ?? null,
+        };
+    });
+    return {
+        projects: enriched,
+        totals: {
+            projects: totals.projects,
+            sessions: totals.sessions,
+            tokens: totals.tokens,
+            credits: totals.credits,
+        },
+    };
 }
 export function upsertTrace(entry) {
     db.prepare(`
@@ -156,3 +271,51 @@ function rowToEntry(row) {
 export function deleteTrace(id) {
     db.prepare('DELETE FROM traces WHERE id = ?').run(id);
 }
+export function getProjectTraces(projectId, limit = 200) {
+    const rows = db.prepare(`
+    SELECT t.* FROM traces t
+    JOIN sessions s ON s.id = t.session_id
+    WHERE s.project_id = ?
+    ORDER BY t.date_time DESC
+    LIMIT ?
+  `).all(projectId, limit);
+    return rows.map((r) => rowToEntry(r));
+}
+export function getProjectSessionSummary(projectId) {
+    const stats = db.prepare(`
+    SELECT
+      COUNT(*) as entries,
+      SUM(t.tokens_input) as input,
+      SUM(t.tokens_output) as output,
+      SUM(t.tokens_cached) as cached,
+      SUM(t.tokens_reasoning) as reasoning,
+      SUM(t.tokens_written) as written,
+      SUM(t.tokens_total) as total,
+      SUM(t.ai_credits) as credits,
+      SUM(t.duration_ms) as duration,
+      SUM(t.skill_count) as skills,
+      SUM(t.agent_count) as agents,
+      SUM(t.mcp_count) as mcps
+    FROM traces t
+    JOIN sessions s ON s.id = t.session_id
+    WHERE s.project_id = ?
+  `).get(projectId);
+    return {
+        sessionId: projectId,
+        startedAt: '',
+        totalEntries: stats.entries || 0,
+        totalTokens: {
+            input: stats.input || 0,
+            output: stats.output || 0,
+            cached: stats.cached || 0,
+            reasoning: stats.reasoning || 0,
+            written: stats.written || 0,
+            total: stats.total || 0,
+        },
+        totalCredits: stats.credits || 0,
+        totalDurationMs: stats.duration || 0,
+        totalSkillCalls: stats.skills || 0,
+        totalAgentCalls: stats.agents || 0,
+        totalMcpCalls: stats.mcps || 0,
+    };
+}

package/dist/otlpReceiver.js

@@ -14,7 +14,8 @@
  *   chat <model> span attrs: same as above
  *   User message event: github.copilot.user.message
  */
-import { upsertTrace, createSession, deleteTrace } from './db.js';
+import { randomUUID } from 'crypto';
+import { upsertTrace, createSession, deleteTrace, ensureProject, ensureProjectByRepo } from './db.js';
 import { traceEvents } from './proxy.js';
 // ── Helpers ───────────────────────────────────────────────────────────────────
 function getAttr(attrs, key) {
@@ -36,21 +37,167 @@ function nanoToMs(nano) {
 function nanoToIso(nano) {
     return new Date(nanoToMs(nano)).toISOString();
 }
+function getStringAttr(attrs, ...keys) {
+    for (const key of keys) {
+        const value = getAttr(attrs, key);
+        if (value !== undefined && String(value).trim())
+            return String(value);
+    }
+    return undefined;
+}
+function getBodyText(body) {
+    if (!body)
+        return undefined;
+    if (body.stringValue !== undefined)
+        return body.stringValue;
+    if (body.intValue !== undefined)
+        return String(body.intValue);
+    if (body.doubleValue !== undefined)
+        return String(body.doubleValue);
+    if (body.boolValue !== undefined)
+        return String(body.boolValue);
+    return undefined;
+}
 const inFlight = new Map(); // traceId → InFlight
-// Sessions we've created in DB (avoid duplicate createSession calls)
-const knownSessions = new Set();
-function ensureSession(sessionId) {
-    if (!knownSessions.has(sessionId)) {
-        createSession(sessionId);
-        knownSessions.add(sessionId);
+// Sessions are created lazily. Always upsert so project_id gets backfilled
+// when the session was created earlier without a project.
+function ensureSession(sessionId, projectId) {
+    createSession(sessionId, projectId);
+}
+// ── Project resolution ────────────────────────────────────────────────────────
+// Precedence: repo URL > working dir > default (CLI) project.
+// If none match, the session keeps no project (traces still appear on live page).
+function resolveProjectId(repoUrl, workingDir, defaultProjectId) {
+    if (repoUrl)
+        return ensureProjectByRepo(String(repoUrl));
+    if (workingDir)
+        return ensureProject(workingDir);
+    return defaultProjectId;
+}
+function detectWorkingDir(attrs) {
+    for (const key of ['process.working_directory', 'github.copilot.working_dir', 'claude_code.working_dir']) {
+        const v = getAttr(attrs, key);
+        if (v && String(v).trim())
+            return String(v).trim();
     }
+    return undefined;
 }
 // ── Process one batch of spans ────────────────────────────────────────────────
 // Track standalone chat entries so invoke_agent can replace them (multiple chat spans per traceId)
 const pendingChatIds = new Map(); // `chat:${traceId}` → list of entryIds
 // Buffer tool calls that arrive before invoke_agent
 const pendingToolCalls = new Map(); // traceId → tool calls
-function processSpans(spans, sessionId) {
+const claudePromptEntries = new Map(); // prompt.id → trace entry
+const claudeInteractionEntries = new Map(); // traceId → interaction entry
+const CLAUDE_STATE_LIMIT = 1000;
+function rememberClaudeEntry(map, key, entry) {
+    map.set(key, entry);
+    if (map.size > CLAUDE_STATE_LIMIT) {
+        const oldest = map.keys().next().value;
+        if (oldest)
+            map.delete(oldest);
+    }
+}
+function claudeEventId(record, attrs, eventName) {
+    const messageId = getStringAttr(attrs, 'message.uuid', 'tool_use_id');
+    const promptId = getStringAttr(attrs, 'prompt.id');
+    return `claude:${messageId ?? promptId ?? record.traceId ?? randomUUID()}:${eventName}`;
+}
+function processClaudeLogRecord(record, resourceAttrs, sessionId, projectId, workingDir) {
+    const attrs = record.attributes ?? [];
+    const eventName = getStringAttr(attrs, 'event.name') ?? getBodyText(record.body);
+    if (!eventName || !eventName.startsWith('claude_code.'))
+        return;
+    const eventTime = getStringAttr(attrs, 'event.timestamp');
+    const dateTime = eventTime ?? (record.timeUnixNano ? nanoToIso(record.timeUnixNano) : new Date().toISOString());
+    const promptId = getStringAttr(attrs, 'prompt.id');
+    const resolvedProjectId = resolveProjectId(getStringAttr(resourceAttrs, 'github.copilot.git.repository', 'vcs.repository.url'), getStringAttr(attrs, 'process.working_directory', 'github.copilot.working_dir', 'claude_code.working_dir') ?? workingDir, projectId);
+    const eventSessionId = getStringAttr(attrs, 'session.id') ?? sessionId;
+    if (eventName === 'claude_code.user_prompt') {
+        const entry = {
+            id: claudeEventId(record, attrs, 'prompt'),
+            sessionId: eventSessionId,
+            dateTime,
+            prompt: getStringAttr(attrs, 'prompt') ?? '[Claude Code prompt]',
+            tokens: { input: 0, output: 0, cached: 0, reasoning: 0, written: 0, total: 0 },
+            aiCredits: 0,
+            durationMs: 0,
+            toolCalls: [],
+            skillCount: 0,
+            agentCount: 0,
+            mcpCount: 0,
+            status: 'running',
+        };
+        if (promptId)
+            rememberClaudeEntry(claudePromptEntries, promptId, entry);
+        ensureSession(eventSessionId, resolvedProjectId);
+        upsertTrace(entry);
+        traceEvents.emit('trace:update', entry);
+        return;
+    }
+    if (eventName === 'claude_code.assistant_response') {
+        const existingEntry = promptId ? claudePromptEntries.get(promptId) : undefined;
+        const entry = existingEntry ?? {
+            id: claudeEventId(record, attrs, 'response'),
+            sessionId: eventSessionId,
+            dateTime,
+            prompt: '[Claude Code response]',
+            tokens: { input: 0, output: 0, cached: 0, reasoning: 0, written: 0, total: 0 },
+            aiCredits: 0,
+            durationMs: 0,
+            toolCalls: [],
+            skillCount: 0,
+            agentCount: 0,
+            mcpCount: 0,
+            status: 'running',
+        };
+        entry.response = getStringAttr(attrs, 'response');
+        entry.status = 'done';
+        entry.durationMs = Number(getStringAttr(attrs, 'duration_ms') ?? 0);
+        ensureSession(eventSessionId, resolvedProjectId);
+        upsertTrace(entry);
+        traceEvents.emit('trace:update', entry);
+        traceEvents.emit('trace:done', entry);
+        return;
+    }
+    if (eventName === 'claude_code.tool_result') {
+        const entry = promptId ? claudePromptEntries.get(promptId) : undefined;
+        if (!entry)
+            return;
+        const toolName = getStringAttr(attrs, 'tool_name') ?? 'Claude Code tool';
+        const toolId = getStringAttr(attrs, 'tool_use_id') ?? randomUUID();
+        if (entry.toolCalls.some(call => call.id === toolId))
+            return;
+        entry.toolCalls.push({
+            id: toolId,
+            name: toolName,
+            type: detectToolType(toolName),
+            input: {},
+            startedAt: Date.parse(dateTime),
+            endedAt: Date.parse(dateTime),
+            durationMs: Number(getStringAttr(attrs, 'duration_ms') ?? 0),
+            error: getStringAttr(attrs, 'error'),
+        });
+        upsertTrace(entry);
+        traceEvents.emit('trace:update', entry);
+    }
+}
+function processClaudeLogs(payload, defaultSessionId, projectId) {
+    if (!payload || !Array.isArray(payload.resourceLogs)) {
+        throw new Error('OTLP logs payload must contain resourceLogs');
+    }
+    for (const resourceLogs of payload.resourceLogs ?? []) {
+        const resourceAttrs = resourceLogs.resource?.attributes ?? [];
+        const sessionId = getStringAttr(resourceAttrs, 'session.id') ?? defaultSessionId;
+        const workingDir = detectWorkingDir(resourceAttrs);
+        for (const scopeLogs of resourceLogs.scopeLogs ?? []) {
+            for (const record of scopeLogs.logRecords ?? []) {
+                processClaudeLogRecord(record, resourceAttrs, sessionId, projectId, workingDir);
+            }
+        }
+    }
+}
+function processSpans(spans, sessionId, projectId, workingDir) {
     for (const span of spans) {
         // DEBUG — log raw span to stderr when COPILOT_TRACER_DEBUG=1
         if (process.env.COPILOT_TRACER_DEBUG === '1') {
@@ -60,11 +207,61 @@ function processSpans(spans, sessionId) {
         const spanName = span.name;
         const traceId = span.traceId;
         const spanId = span.spanId;
+        if (spanName === 'claude_code.interaction') {
+            const attrs = span.attributes ?? [];
+            const inputTokens = Number(getAttr(attrs, 'input_tokens') ?? 0);
+            const outputTokens = Number(getAttr(attrs, 'output_tokens') ?? 0);
+            const entry = {
+                id: spanId,
+                sessionId: getStringAttr(attrs, 'session.id') ?? sessionId,
+                dateTime: nanoToIso(span.startTimeUnixNano),
+                prompt: getStringAttr(attrs, 'user_prompt') ?? '[Claude Code interaction]',
+                tokens: { input: inputTokens, output: outputTokens, cached: Number(getAttr(attrs, 'cache_read_tokens') ?? 0), reasoning: 0, written: outputTokens, total: inputTokens + outputTokens },
+                aiCredits: Number(getAttr(attrs, 'cost_usd') ?? 0),
+                durationMs: Number(getAttr(attrs, 'interaction.duration_ms')
+                    ?? (nanoToMs(span.endTimeUnixNano) - nanoToMs(span.startTimeUnixNano))),
+                toolCalls: [],
+                skillCount: 0,
+                agentCount: 0,
+                mcpCount: 0,
+                status: (span.status?.code ?? 0) === 2 ? 'error' : 'done',
+                error: span.status?.message,
+            };
+            ensureSession(entry.sessionId, resolveProjectId(getAttr(attrs, 'vcs.repository.url'), detectWorkingDir(attrs) ?? workingDir, projectId));
+            upsertTrace(entry);
+            rememberClaudeEntry(claudeInteractionEntries, traceId, entry);
+            traceEvents.emit('trace:update', entry);
+            traceEvents.emit('trace:done', entry);
+            continue;
+        }
+        if (spanName === 'claude_code.llm_request') {
+            const inputTokens = Number(getAttr(attrs, 'input_tokens') ?? 0);
+            const outputTokens = Number(getAttr(attrs, 'output_tokens') ?? 0);
+            const cachedTokens = Number(getAttr(attrs, 'cache_read_tokens') ?? 0);
+            const entry = claudeInteractionEntries.get(traceId);
+            if (entry) {
+                entry.tokens = {
+                    input: entry.tokens.input + inputTokens,
+                    output: entry.tokens.output + outputTokens,
+                    cached: entry.tokens.cached + cachedTokens,
+                    reasoning: 0,
+                    written: entry.tokens.written + outputTokens,
+                    total: entry.tokens.total + inputTokens + outputTokens,
+                };
+                entry.aiCredits += Number(getAttr(attrs, 'cost_usd') ?? 0);
+                upsertTrace(entry);
+                traceEvents.emit('trace:update', entry);
+            }
+            continue;
+        }
         // ── invoke_agent span = top-level agent turn ──────────────────────────
         if (spanName === 'invoke_agent') {
             const startMs = nanoToMs(span.startTimeUnixNano);
             const endMs = nanoToMs(span.endTimeUnixNano);
             const durationMs = endMs - startMs;
+            // Extract repo URL for auto project detection
+            const repoUrl = getAttr(attrs, 'github.copilot.git.repository');
+            const resolvedProjectId = resolveProjectId(repoUrl, workingDir, projectId);
             // Extract prompt from gen_ai.input.messages (real attr name from copilot)
             let promptText = '';
             let responseText = '';
@@ -213,7 +410,7 @@ function processSpans(spans, sessionId) {
                 inf.entry.mcpCount = mcps;
                 pendingToolCalls.delete(traceId);
             }
-            ensureSession(sessionId);
+            ensureSession(sessionId, resolvedProjectId);
             upsertTrace(entry);
             traceEvents.emit('trace:update', entry);
             traceEvents.emit('trace:done', entry);
@@ -276,7 +473,7 @@ function processSpans(spans, sessionId) {
                     skillCount: 0, agentCount: 0, mcpCount: 0,
                     status: 'done',
                 };
-                ensureSession(sessionId);
+                ensureSession(sessionId, resolveProjectId(getAttr(attrs, 'github.copilot.git.repository'), workingDir, projectId));
                 upsertTrace(entry);
                 const chatKey = `chat:${traceId}`;
                 const existing = pendingChatIds.get(chatKey) ?? [];
@@ -383,7 +580,7 @@ function detectToolType(name) {
     return 'builtin';
 }
 // ── Register OTLP HTTP routes on the Express app ──────────────────────────────
-export function registerOtlpRoutes(app, defaultSessionId) {
+export function registerOtlpRoutes(app, defaultSessionId, projectId) {
     // OTLP traces — copilot sends JSON (http/json protocol)
     // body already parsed by express.json() middleware registered before this call
     app.post('/v1/traces', (req, res) => {
@@ -396,8 +593,9 @@ export function registerOtlpRoutes(app, defaultSessionId) {
                     ?? getAttr(resAttrs, 'session.id')
                     ?? getAttr(resAttrs, 'github.copilot.conversation_id');
                 const sessionId = String(sessionFromOtel ?? defaultSessionId);
+                const workingDir = detectWorkingDir(resAttrs);
                 for (const ss of rs.scopeSpans ?? []) {
-                    processSpans(ss.spans ?? [], sessionId);
+                    processSpans(ss.spans ?? [], sessionId, projectId, workingDir);
                 }
             }
             res.status(200).json({ partialSuccess: {} });
@@ -407,8 +605,17 @@ export function registerOtlpRoutes(app, defaultSessionId) {
             res.status(400).json({ error: 'invalid payload' });
         }
     });
-    // Metrics + logs — accept and ignore
+    app.post('/v1/logs', (req, res) => {
+        try {
+            processClaudeLogs(req.body, defaultSessionId, projectId);
+            res.status(200).json({ partialSuccess: {} });
+        }
+        catch (e) {
+            console.error('[OTLP] log parse error:', e);
+            res.status(400).json({ error: 'invalid payload' });
+        }
+    });
+    // Metrics remain accepted for Claude Code dashboards but are not trace entries.
     app.post('/v1/metrics', (_req, res) => res.status(200).json({ partialSuccess: {} }));
-    app.post('/v1/logs', (_req, res) => res.status(200).json({ partialSuccess: {} }));
-    console.log('  📡 OTLP receiver ready on /v1/traces');
+    console.log('  📡 OTLP receiver ready on /v1/traces and /v1/logs');
 }

package/dist/setup.js

@@ -1,5 +1,5 @@
 /**
- * copilot-tracer setup — auto-detect copilot CLI + VS Code and inject OTLP env config
+ * copilot-tracer setup — auto-detect Copilot/VS Code and inject OTLP env config
  *
  * What it does:
  *  1. Detect copilot CLI (which copilot)
@@ -16,12 +16,62 @@ import os from 'os';
 const OTEL_ENDPOINT_KEY = 'OTEL_EXPORTER_OTLP_ENDPOINT';
 const OTEL_CONTENT_KEY = 'OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT';
 const OTEL_ENABLED_KEY = 'COPILOT_OTEL_ENABLED';
+const CLAUDE_TELEMETRY_KEY = 'CLAUDE_CODE_ENABLE_TELEMETRY';
+const CLAUDE_TRACES_KEY = 'CLAUDE_CODE_ENHANCED_TELEMETRY_BETA';
+const OTEL_LOGS_EXPORTER_KEY = 'OTEL_LOGS_EXPORTER';
+const OTEL_TRACES_EXPORTER_KEY = 'OTEL_TRACES_EXPORTER';
+const OTEL_PROTOCOL_KEY = 'OTEL_EXPORTER_OTLP_PROTOCOL';
+const OTEL_LOG_PROMPTS_KEY = 'OTEL_LOG_USER_PROMPTS';
+const OTEL_LOG_RESPONSES_KEY = 'OTEL_LOG_ASSISTANT_RESPONSES';
 function otelEnvBlock(port) {
     return [
         `# >>> copilot-tracer OTLP config (auto-added) >>>`,
         `export ${OTEL_ENDPOINT_KEY}=http://localhost:${port}`,
         `export ${OTEL_CONTENT_KEY}=true`,
         `export ${OTEL_ENABLED_KEY}=true`,
+        `export ${CLAUDE_TELEMETRY_KEY}=1`,
+        `export ${CLAUDE_TRACES_KEY}=1`,
+        `export ${OTEL_LOGS_EXPORTER_KEY}=otlp`,
+        `export ${OTEL_TRACES_EXPORTER_KEY}=otlp`,
+        `export ${OTEL_PROTOCOL_KEY}=http/json`,
+        `export ${OTEL_LOG_PROMPTS_KEY}=1`,
+        `export ${OTEL_LOG_RESPONSES_KEY}=1`,
+        ``,
+        `# Tag every copilot prompt with the terminal folder it ran from, so the`,
+        `# tracer can attribute it to the right project. OTLP carries no working-dir,`,
+        `# so we inject it via OTEL_RESOURCE_ATTRIBUTES (percent-encoded).`,
+        `copilot() {`,
+        `  local _wd`,
+        `  if command -v python3 >/dev/null 2>&1; then`,
+        `    _wd="$(pwd | python3 -c 'import sys,urllib.parse;print(urllib.parse.quote(sys.stdin.read().strip(), safe="/"))')"`,
+        `  else`,
+        `    _wd="$(pwd)"`,
+        `  fi`,
+        `  if [ -n "\${OTEL_RESOURCE_ATTRIBUTES:-}" ]; then`,
+        `    # Drop any stale working_dir entry, then append the current folder`,
+        `    OTEL_RESOURCE_ATTRIBUTES="$(printf '%s' "\$OTEL_RESOURCE_ATTRIBUTES" | sed -E 's/(^|,)github\.copilot\.working_dir=[^,]*/\\1/g; s/^,//')"`,
+        `    [ -z "\$OTEL_RESOURCE_ATTRIBUTES" ] || OTEL_RESOURCE_ATTRIBUTES="\${OTEL_RESOURCE_ATTRIBUTES},"`,
+        `  fi`,
+        `  OTEL_RESOURCE_ATTRIBUTES="\${OTEL_RESOURCE_ATTRIBUTES}github.copilot.working_dir=\${_wd}"`,
+        `  export OTEL_RESOURCE_ATTRIBUTES`,
+        `  command copilot "\$@"`,
+        `}`,
+        ``,
+        `claude() {`,
+        `  local _wd`,
+        `  if command -v python3 >/dev/null 2>&1; then`,
+        `    _wd="$(pwd | python3 -c 'import sys,urllib.parse;print(urllib.parse.quote(sys.stdin.read().strip(), safe="/"))')"`,
+        `  else`,
+        `    _wd="$(pwd)"`,
+        `  fi`,
+        `  if [ -n "\${OTEL_RESOURCE_ATTRIBUTES:-}" ]; then`,
+        `    OTEL_RESOURCE_ATTRIBUTES="\${OTEL_RESOURCE_ATTRIBUTES},claude_code.working_dir=\${_wd}"`,
+        `  else`,
+        `    OTEL_RESOURCE_ATTRIBUTES="claude_code.working_dir=\${_wd}"`,
+        `  fi`,
+        `  export OTEL_RESOURCE_ATTRIBUTES`,
+        `  command claude "\$@"`,
+        `}`,
         `# <<< copilot-tracer <<<`,
     ].join('\n');
 }
@@ -30,6 +80,13 @@ function vscodeEnvBlock(port) {
         [OTEL_ENDPOINT_KEY]: `http://localhost:${port}`,
         [OTEL_CONTENT_KEY]: 'true',
         [OTEL_ENABLED_KEY]: 'true',
+        [CLAUDE_TELEMETRY_KEY]: '1',
+        [CLAUDE_TRACES_KEY]: '1',
+        [OTEL_LOGS_EXPORTER_KEY]: 'otlp',
+        [OTEL_TRACES_EXPORTER_KEY]: 'otlp',
+        [OTEL_PROTOCOL_KEY]: 'http/json',
+        [OTEL_LOG_PROMPTS_KEY]: '1',
+        [OTEL_LOG_RESPONSES_KEY]: '1',
     };
 }
 // ── Detection helpers ─────────────────────────────────────────────────────────
@@ -130,7 +187,7 @@ function patchVSCodeSettings(settingsPath, port) {
     return { action: wasSet ? 'updated' : 'added' };
 }
 // ── Main setup ────────────────────────────────────────────────────────────────
-export function runSetup(port) {
+export function runSetup(port, silent = false) {
     const CHECK = '✅';
     const WARN = '⚠️ ';
     const INFO = '📍';
@@ -173,12 +230,13 @@ export function runSetup(port) {
         const label = path.basename(profilePath);
         if (result.action === 'added') {
             console.log(`\n${CHECK} Shell profile patched: ${label}`);
-            console.log(`   ${ARROW} Added OTEL env vars (endpoint, content capture)`);
+            console.log(`   ${ARROW} Added Copilot + Claude Code OTLP env vars`);
+            console.log(`   ${ARROW} Added copilot() wrapper — tags each prompt with the terminal folder`);
             console.log(`   ${ARROW} Run: source ${profilePath}`);
         }
         else if (result.action === 'updated') {
             console.log(`\n${CHECK} Shell profile updated: ${label}`);
-            console.log(`   ${ARROW} Updated port to ${port}`);
+            console.log(`   ${ARROW} Updated port to ${port} + Claude Code/Copilot OTLP config`);
             console.log(`   ${ARROW} Run: source ${profilePath}`);
         }
         else {
@@ -210,15 +268,24 @@ export function runSetup(port) {
     process.env[OTEL_ENDPOINT_KEY] = `http://localhost:${port}`;
     process.env[OTEL_CONTENT_KEY] = 'true';
     process.env[OTEL_ENABLED_KEY] = 'true';
+    process.env[CLAUDE_TELEMETRY_KEY] = '1';
+    process.env[CLAUDE_TRACES_KEY] = '1';
+    process.env[OTEL_LOGS_EXPORTER_KEY] = 'otlp';
+    process.env[OTEL_TRACES_EXPORTER_KEY] = 'otlp';
+    process.env[OTEL_PROTOCOL_KEY] = 'http/json';
+    process.env[OTEL_LOG_PROMPTS_KEY] = '1';
+    process.env[OTEL_LOG_RESPONSES_KEY] = '1';
     // 6. Summary
-    const profileBase = profilePath ? path.basename(profilePath) : '.zshrc';
-    console.log('\n────────────────────────────────────────────────');
-    console.log('  One manual step required:\n');
-    console.log(`  source ~/${profileBase}`);
-    console.log(`  (opens a new terminal already? — env is already active there)`);
-    if (vscode.found)
-        console.log('\n  Restart VS Code once to pick up the new terminal env.');
-    console.log('\n  ✨ Starting tracer web UI now...');
-    console.log(`  Open: http://localhost:${port}/`);
-    console.log('────────────────────────────────────────────────\n');
+    if (!silent) {
+        const profileBase = profilePath ? path.basename(profilePath) : '.zshrc';
+        console.log('\n────────────────────────────────────────────────');
+        console.log('  One manual step required:\n');
+        console.log(`  source ~/${profileBase}`);
+        console.log(`  (opens a new terminal already? — env is already active there)`);
+        if (vscode.found)
+            console.log('\n  Restart VS Code once to pick up the new terminal env.');
+        console.log('\n  ✨ Starting tracer web UI now...');
+        console.log(`  Open: http://localhost:${port}/`);
+        console.log('────────────────────────────────────────────────\n');
+    }
 }