agent-dir 0.4.1 → 0.5.0

package/dist/src/mcp.js

@@ -1,6 +1,7 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { hostname, userInfo } from "node:os";
+import { hostname, release, userInfo } from "node:os";
 import { CodeGraphIntegration } from "./codegraph.js";
 import { TelemetryRecorder } from "./telemetry/recorder.js";
 import { findDefinition, findExports, findFiles, findImports, findReferences, findSymbol, searchCode, searchFiles, } from "./tools/code.js";
@@ -345,6 +346,9 @@ export function createMcpHandler(root, commandConfig = {}, telemetry = { level:
     let sessionToolCallCount = 0;
     let sessionCommandCallCount = 0;
     let sessionRecorded = false;
+    let sessionOutputBytes = 0;
+    let sessionEstimatedOutputTokens = 0;
+    const seenOutputFingerprints = new Set();
     const telemetryProjectPromise = telemetry.level === "detailed" || telemetry.level === "diagnostic"
         ? buildTelemetryProjectContext(root, codeGraph).catch(() => undefined)
         : undefined;
@@ -570,16 +574,30 @@ export function createMcpHandler(root, commandConfig = {}, telemetry = { level:
                         const result = await callTool(toolName, argumentsValue, root, npmAllowed, allowedCommands, blacklistedCommands, gitEnabled, notify, request.signal, codeGraph);
                         const durationMs = performance.now() - startedAt;
                         const count = resultCount(result);
+                        const serializedResult = JSON.stringify(result);
+                        const outputBytes = Buffer.byteLength(serializedResult, "utf8");
+                        const estimatedOutputTokens = estimateTokens(serializedResult);
+                        sessionOutputBytes += outputBytes;
+                        sessionEstimatedOutputTokens += estimatedOutputTokens;
                         const runtime = telemetryRuntime(params);
                         telemetryRecorder.record({
                             event: "tool_call",
                             tool: toolName,
+                            requestIdHash: telemetryHash(String(message.id)),
                             success: true,
                             durationMs,
                             inputBytes: Buffer.byteLength(JSON.stringify(argumentsValue), "utf8"),
-                            outputBytes: Buffer.byteLength(JSON.stringify(result), "utf8"),
+                            outputBytes,
+                            estimatedInputTokens: estimateTokens(JSON.stringify(argumentsValue)),
+                            estimatedOutputTokens,
+                            cumulativeOutputBytes: sessionOutputBytes,
+                            cumulativeEstimatedOutputTokens: sessionEstimatedOutputTokens,
+                            inputFingerprint: telemetryHash(JSON.stringify({ toolName, argumentsValue })),
+                            ...(telemetry.level === "diagnostic"
+                                ? { diagnosticDetails: diagnosticToolDetails(argumentsValue, result) }
+                                : {}),
                             ...(count === undefined ? {} : { resultCount: count }),
-                            ...toolTelemetryMetrics(toolName, result),
+                            ...toolTelemetryMetrics(toolName, result, seenOutputFingerprints),
                         }, runtime, telemetryProject);
                         const command = commandTelemetryDescriptor(toolName);
                         if (command) {
@@ -590,7 +608,7 @@ export function createMcpHandler(root, commandConfig = {}, telemetry = { level:
                                 operation: command.operation,
                                 success: true,
                                 durationMs,
-                                outputBytes: Buffer.byteLength(JSON.stringify(result), "utf8"),
+                                outputBytes,
                             }, runtime, telemetryProject);
                         }
                         mcpSuccess = true;
@@ -607,9 +625,21 @@ export function createMcpHandler(root, commandConfig = {}, telemetry = { level:
                         telemetryRecorder.record({
                             event: "tool_call",
                             tool: toolName,
+                            requestIdHash: telemetryHash(String(message.id)),
                             success: false,
                             durationMs,
                             inputBytes: Buffer.byteLength(JSON.stringify(argumentsValue), "utf8"),
+                            estimatedInputTokens: estimateTokens(JSON.stringify(argumentsValue)),
+                            inputFingerprint: telemetryHash(JSON.stringify({ toolName, argumentsValue })),
+                            ...(telemetry.level === "diagnostic"
+                                ? {
+                                    diagnosticDetails: diagnosticToolDetails(argumentsValue, {
+                                        error: error instanceof Error
+                                            ? { name: error.name, message: error.message, stack: error.stack }
+                                            : String(error),
+                                    }),
+                                }
+                                : {}),
                             errorCategory,
                         }, runtime, telemetryProject);
                         const command = commandTelemetryDescriptor(toolName);
@@ -1554,6 +1584,8 @@ function telemetryRuntime(params) {
         ...(typeof clientInfo?.name === "string" ? { mcpClientName: clientInfo.name } : {}),
         ...(typeof clientInfo?.version === "string" ? { mcpClientVersion: clientInfo.version } : {}),
         nodeVersion: process.versions.node,
+        ...linuxDistribution(),
+        kernelVersion: release(),
         hostname: hostname(),
         username: userInfo().username,
         processId: process.pid,
@@ -1562,37 +1594,106 @@ function telemetryRuntime(params) {
         memoryRssBytes: process.memoryUsage().rss,
     };
 }
-function toolTelemetryMetrics(toolName, result) {
+function linuxDistribution() {
+    if (process.platform !== "linux")
+        return {};
+    try {
+        const values = Object.fromEntries(readFileSync("/etc/os-release", "utf8")
+            .split("\n")
+            .map((line) => line.match(/^([A-Z_]+)=(.*)$/))
+            .filter((match) => match !== null)
+            .map((match) => [match[1], match[2]?.replace(/^"|"$/g, "")]));
+        return {
+            ...(values.ID ? { distroId: values.ID } : {}),
+            ...(values.PRETTY_NAME ? { distroName: values.PRETTY_NAME } : {}),
+            ...(values.VERSION_ID ? { distroVersion: values.VERSION_ID } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function diagnosticToolDetails(input, output) {
+    const serialize = (value) => {
+        try {
+            const json = JSON.stringify(value);
+            if (json === undefined)
+                return null;
+            if (Buffer.byteLength(json, "utf8") <= 64_000)
+                return value;
+            return {
+                truncated: true,
+                byteLength: Buffer.byteLength(json, "utf8"),
+                preview: json.slice(0, 64_000),
+            };
+        }
+        catch {
+            return { serializationFailed: true };
+        }
+    };
+    return { input: serialize(input), output: serialize(output) };
+}
+function telemetryHash(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+// A rough byte-based proxy, not a model-tokenizer count or Claude billing measurement.
+function estimateTokens(value) {
+    return Math.ceil(Buffer.byteLength(value, "utf8") / 4);
+}
+function toolTelemetryMetrics(toolName, result, seenOutputFingerprints) {
     const structured = result.structuredContent;
     if (!Array.isArray(structured) && !isRecord(structured))
         return {};
     const paths = new Set();
+    const files = new Map();
     let truncated = false;
     let paginated = false;
+    let textOutputBytes = 0;
     const visit = (value) => {
+        if (typeof value === "string") {
+            textOutputBytes += Buffer.byteLength(value, "utf8");
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const child of value)
+                visit(child);
+            return;
+        }
         if (!isRecord(value))
             return;
-        if (typeof value.path === "string")
+        if (typeof value.path === "string") {
             paths.add(value.path);
+            const content = typeof value.content === "string" ? value.content : undefined;
+            files.set(value.path, {
+                pathHash: telemetryHash(value.path),
+                ...(content === undefined ? {} : { contentHash: telemetryHash(content) }),
+                bytes: content === undefined ? 0 : Buffer.byteLength(content, "utf8"),
+            });
+        }
         if (value.truncated === true)
             truncated = true;
         if (value.nextCursor !== undefined)
             paginated = true;
-        for (const child of Object.values(value)) {
-            if (Array.isArray(child))
-                for (const item of child)
-                    visit(item);
-            else if (isRecord(child))
-                visit(child);
-        }
+        for (const child of Object.values(value))
+            visit(child);
     };
     visit(structured);
+    const outputJson = JSON.stringify(result);
+    const outputFingerprint = telemetryHash(outputJson);
+    const outputBytes = Buffer.byteLength(outputJson, "utf8");
+    const duplicateOutputBytes = seenOutputFingerprints.has(outputFingerprint) ? outputBytes : 0;
+    seenOutputFingerprints.add(outputFingerprint);
     return {
         ...(paths.size > 0 && /^(write|patch|delete|read|file|git_changes|inspect)/.test(toolName)
             ? { affectedFiles: paths.size }
             : {}),
         ...(truncated ? { truncated: true } : {}),
         ...(paginated ? { paginated: true } : {}),
+        outputFingerprint,
+        duplicateOutputBytes,
+        textOutputBytes,
+        uniqueFileCount: files.size,
+        ...(files.size ? { files: [...files.values()].slice(0, 100) } : {}),
     };
 }
 function commandTelemetryDescriptor(toolName) {

package/dist/src/server.js

@@ -16,7 +16,7 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
         level: telemetry.level,
         persist: telemetry.persist ?? false,
         ...(telemetry.configId ? { configId: telemetry.configId } : {}),
-        sessionId: `http-${Date.now()}`,
+        sessionId: telemetry.sessionId ?? `http-${Date.now()}`,
     });
     const server = http.createServer(async (req, res) => {
         const startedAt = performance.now();
@@ -29,6 +29,11 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
         const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
         let authenticated = false;
         try {
+            if (url.pathname === HEALTH_PATH && req.method === "HEAD") {
+                res.setHeader("cache-control", "no-store");
+                sendText(res, 200, "ok\n");
+                return;
+            }
             const body = await readBody(req, requestController.signal);
             const requestInit = {
                 method: req.method ?? "GET",
@@ -51,10 +56,6 @@ export function startServer({ root, port, token, commandConfig = {}, telemetry =
                 recordHttpTelemetry(httpTelemetry, req.method ?? "UNKNOWN", url.pathname, 401, authenticated, startedAt);
                 return;
             }
-            if (url.pathname === HEALTH_PATH && req.method === "HEAD") {
-                sendText(res, 200, "ok\n");
-                return;
-            }
             if (url.pathname === "/mcp") {
                 if (req.method !== "POST") {
                     res.setHeader("allow", "POST");

package/dist/src/setup.js

@@ -104,12 +104,26 @@ export async function runFirstTimeSetup(config, defaultDirectory = ".") {
         const name = await requiredText(rl, "Profile name", "default");
         const directory = resolve(await requiredText(rl, "Directory to expose", defaultDirectory));
         const port = await requiredPort(rl, 3002);
-        const tunnel = await choose(rl, "Tunnel", ["wormhole", "none"], "wormhole");
+        let hostname;
+        let cloudflaredToken;
         let subdomain;
-        if (tunnel === "wormhole" &&
+        console.log("");
+        console.log(`${section("◆")} ${section(bold("Cloudflare Tunnel"))}`);
+        console.log(rule());
+        const useCloudflared = await confirm(rl, "Set up Cloudflare Tunnel?", true);
+        if (useCloudflared) {
+            hostname = await requiredHostname(rl, "Public hostname (must be routed to this tunnel)");
+            cloudflaredToken = await requiredSecret(rl, "Cloudflare tunnel token");
+        }
+        console.log("");
+        console.log(`${section("◆")} ${section(bold("Wormhole"))}`);
+        console.log(rule());
+        const useWormhole = await confirm(rl, "Set up Wormhole too?", false);
+        if (useWormhole &&
             (await confirm(rl, "Use a custom Wormhole subdomain? (No uses a random URL.)", false))) {
             subdomain = await requiredText(rl, "Wormhole subdomain");
         }
+        const tunnel = useCloudflared ? "cloudflared" : useWormhole ? "wormhole" : "none";
         const npm = await optionalList(rl, "Allowed npm scripts (comma-separated, blank for none)");
         const commands = await optionalList(rl, "Allowed commands (comma-separated, blank for none)");
         console.log("");
@@ -119,9 +133,9 @@ export async function runFirstTimeSetup(config, defaultDirectory = ".") {
             bold("Privacy first"),
             dim("Telemetry is optional and stays local on this machine."),
             dim("It helps us understand usage, failures, and reliability improvements."),
-            dim("Standard levels never record file contents, command arguments, tokens,"),
-            dim("environment variables, or project paths."),
-            dim("Diagnostic mode is a separate opt-in local troubleshooting mode and records identifying metadata."),
+            dim("Standard levels avoid file contents, command arguments, tokens, and project paths."),
+            dim("Diagnostic mode records bounded raw tool inputs/outputs and identifying metadata."),
+            dim("It may contain source code or other sensitive project data; it stays local."),
         ]);
         console.log("");
         console.log(`  ${green("●")} ${white("none")}       ${dim("disabled")}`);
@@ -131,9 +145,25 @@ export async function runFirstTimeSetup(config, defaultDirectory = ".") {
         console.log(`  ${cyan("●")} ${white("diagnostic")} ${dim("detailed + local paths, host/user, PID, Node version, memory/uptime")}`);
         console.log("");
         const telemetry = await choose(rl, "Telemetry level", ["none", "anonymous", "basic", "detailed", "diagnostic"], "none");
-        const profile = { directory, port, tunnel, token: randomBytes(24).toString("hex") };
+        const profile = {
+            directory,
+            port,
+            tunnel,
+            defaultTunnel: tunnel,
+            token: randomBytes(24).toString("hex"),
+        };
         if (subdomain)
             profile.subdomain = subdomain;
+        if (hostname)
+            profile.hostname = hostname;
+        if (useCloudflared || useWormhole) {
+            profile.tunnels = {
+                ...(useWormhole ? { wormhole: { ...(subdomain ? { subdomain } : { random: true }) } } : {}),
+                ...(useCloudflared && hostname
+                    ? { cloudflared: { hostname, ...(cloudflaredToken ? { token: cloudflaredToken } : {}) } }
+                    : {}),
+            };
+        }
         if (npm.length)
             profile.npm = { allowedScripts: npm };
         if (commands.length)
@@ -168,6 +198,37 @@ async function requiredText(rl, label, defaultValue) {
         console.log(`  ${error("✕")} ${dim("A value is required.")}`);
     }
 }
+async function requiredSecret(rl, label) {
+    while (true) {
+        output.write(`  ${bold(label)}: `);
+        const writableRl = rl;
+        const writeToOutput = writableRl._writeToOutput;
+        writableRl._writeToOutput = () => { };
+        let value;
+        try {
+            value = (await rl.question("")).trim();
+        }
+        finally {
+            writableRl._writeToOutput = writeToOutput;
+            output.write("\n");
+        }
+        if (value)
+            return value;
+        console.log(`  ${error("✕")} ${dim("A value is required.")}`);
+    }
+}
+async function requiredHostname(rl, label) {
+    while (true) {
+        const value = (await rl.question(`  ${bold(label)}: `)).trim().toLowerCase();
+        const labels = value.split(".");
+        const valid = value.length <= 253 &&
+            labels.length >= 2 &&
+            labels.every((part) => part.length >= 1 && part.length <= 63 && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(part));
+        if (valid)
+            return value;
+        console.log(`  ${error("✕")} ${dim("Enter a hostname only, such as agent-dir-mcp.scriptr.uk (no spaces, https://, or path).")}`);
+    }
+}
 async function requiredPort(rl, defaultValue) {
     while (true) {
         const value = (await rl.question(`  ${bold("Port")} ${dim(`[${defaultValue}]`)}: `)).trim() ||

package/dist/src/telemetry/privacy.js

@@ -40,6 +40,33 @@ export function sanitizeAnonymousEvent(event) {
         return {
             event: "tool_call",
             tool: sanitizeIdentifier(event.tool, SAFE_TOOL_NAME),
+            ...(event.requestIdHash === undefined
+                ? {}
+                : { requestIdHash: sanitizeHash(event.requestIdHash) }),
+            ...(event.inputFingerprint === undefined
+                ? {}
+                : { inputFingerprint: sanitizeHash(event.inputFingerprint) }),
+            ...(event.outputFingerprint === undefined
+                ? {}
+                : { outputFingerprint: sanitizeHash(event.outputFingerprint) }),
+            ...optionalNumber("estimatedInputTokens", event.estimatedInputTokens),
+            ...optionalNumber("estimatedOutputTokens", event.estimatedOutputTokens),
+            ...optionalNumber("cumulativeOutputBytes", event.cumulativeOutputBytes),
+            ...optionalNumber("cumulativeEstimatedOutputTokens", event.cumulativeEstimatedOutputTokens),
+            ...optionalNumber("duplicateOutputBytes", event.duplicateOutputBytes),
+            ...optionalNumber("textOutputBytes", event.textOutputBytes),
+            ...optionalNumber("uniqueFileCount", event.uniqueFileCount),
+            ...(event.files === undefined
+                ? {}
+                : {
+                    files: event.files.slice(0, 100).map((file) => ({
+                        pathHash: sanitizeHash(file.pathHash),
+                        ...(file.contentHash === undefined
+                            ? {}
+                            : { contentHash: sanitizeHash(file.contentHash) }),
+                        bytes: boundedNumber(file.bytes),
+                    })),
+                }),
             success: event.success === true,
             durationMs: boundedNumber(event.durationMs),
             ...optionalNumber("inputBytes", event.inputBytes),
@@ -100,6 +127,12 @@ export function createTelemetryEnvelope(level, event, runtime, project, configId
         level,
         event: sanitizeAnonymousEvent(event),
     };
+    if (level === "diagnostic" &&
+        event.event === "tool_call" &&
+        event.diagnosticDetails &&
+        envelope.event.event === "tool_call") {
+        envelope.event.diagnosticDetails = event.diagnosticDetails;
+    }
     if (level === "basic" || level === "detailed" || level === "diagnostic") {
         if (runtime)
             envelope.runtime = sanitizeRuntimeContext(runtime);
@@ -121,6 +154,16 @@ function sanitizeDiagnosticRuntimeContext(context) {
         ...(context.nodeVersion === undefined
             ? {}
             : { nodeVersion: sanitizeVersion(context.nodeVersion) }),
+        ...(context.distroId === undefined
+            ? {}
+            : { distroId: sanitizeSensitiveIdentifier(context.distroId) }),
+        ...(context.distroName === undefined ? {} : { distroName: context.distroName.slice(0, 128) }),
+        ...(context.distroVersion === undefined
+            ? {}
+            : { distroVersion: context.distroVersion.slice(0, 64) }),
+        ...(context.kernelVersion === undefined
+            ? {}
+            : { kernelVersion: context.kernelVersion.slice(0, 128) }),
         ...(context.hostname === undefined
             ? {}
             : { hostname: sanitizeSensitiveIdentifier(context.hostname) }),
@@ -202,6 +245,9 @@ function sanitizeVersion(value) {
         ? normalized
         : "unknown";
 }
+function sanitizeHash(value) {
+    return /^[a-f0-9]{64}$/.test(value) ? value : "unknown";
+}
 function sanitizeErrorCategory(value) {
     const normalized = value.trim().toLowerCase();
     return SAFE_ERROR_CATEGORIES.has(normalized) ? normalized : "unknown";

package/dist/src/telemetry/recorder.js

@@ -1,10 +1,9 @@
+import { randomUUID } from "node:crypto";
 import { appendFileSync, chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname } from "node:path";
 import { createTelemetryEnvelope } from "./privacy.js";
+import { telemetrySessionPath } from "./storage.js";
 const DEFAULT_MAX_EVENTS = 500;
-const DEFAULT_PERSISTED_EVENTS = 500;
-const TELEMETRY_FILE = join(homedir(), ".config", "agent-dir", "telemetry.jsonl");
 export class TelemetryRecorder {
     level;
     maxEvents;
@@ -21,9 +20,9 @@ export class TelemetryRecorder {
         this.runtime = options.runtime;
         this.project = options.project;
         this.persist = options.persist ?? false;
-        this.persistPath = options.persistPath ?? TELEMETRY_FILE;
         this.configId = options.configId ?? "default";
-        this.sessionId = options.sessionId ?? "default";
+        this.sessionId = options.sessionId ?? randomUUID();
+        this.persistPath = options.persistPath ?? telemetrySessionPath(this.configId, this.sessionId);
         if (this.persist && this.level !== "none")
             this.loadPersisted();
     }
@@ -64,8 +63,9 @@ export class TelemetryRecorder {
                 .filter((event) => event &&
                 event.schemaVersion === 1 &&
                 event.level === this.level &&
-                event.configId === this.configId)
-                .slice(-Math.min(this.maxEvents, DEFAULT_PERSISTED_EVENTS));
+                event.configId === this.configId &&
+                event.sessionId === this.sessionId)
+                .slice(-this.maxEvents);
             this.events.push(...persisted);
         }
         catch {
@@ -80,15 +80,6 @@ export class TelemetryRecorder {
                 mode: 0o600,
             });
             chmodSync(this.persistPath, 0o600);
-            if (this.events.length === this.maxEvents) {
-                const lines = readFileSync(this.persistPath, "utf8").split("\n").filter(Boolean);
-                if (lines.length > this.maxEvents) {
-                    writeFileSync(this.persistPath, `${lines.slice(-this.maxEvents).join("\n")}\n`, {
-                        encoding: "utf8",
-                        mode: 0o600,
-                    });
-                }
-            }
         }
         catch {
             // Telemetry persistence must never affect the MCP request path.

package/dist/src/telemetry/storage.d.ts

@@ -0,0 +1,9 @@
+import type { TelemetryEnvelope } from "./types.js";
+export declare const TELEMETRY_DIRECTORY: string;
+export declare const LEGACY_TELEMETRY_FILE: string;
+export declare function telemetrySessionPath(configId: string, sessionId: string): string;
+/** Migrate the old shared file once, preserving an archive and avoiding duplicate lines. */
+export declare function migrateLegacyTelemetry(): void;
+export declare function readAllTelemetryEvents(): TelemetryEnvelope[];
+export declare function resetTelemetry(profile?: string, all?: boolean): void;
+export declare function ensureTelemetryDirectory(): void;

package/dist/src/telemetry/storage.js

@@ -0,0 +1,133 @@
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const CONFIG_DIRECTORY = join(homedir(), ".config", "agent-dir");
+export const TELEMETRY_DIRECTORY = join(CONFIG_DIRECTORY, "telemetry");
+export const LEGACY_TELEMETRY_FILE = join(CONFIG_DIRECTORY, "telemetry.jsonl");
+const LEGACY_ARCHIVE_FILE = join(CONFIG_DIRECTORY, "telemetry.legacy-archive.jsonl");
+function safeSegment(value) {
+    const safe = value
+        .replace(/[^A-Za-z0-9._-]/g, "_")
+        .replace(/^\.+$/, "_")
+        .slice(0, 100);
+    return safe || "unknown";
+}
+export function telemetrySessionPath(configId, sessionId) {
+    return join(TELEMETRY_DIRECTORY, safeSegment(configId), `session-${safeSegment(sessionId)}.jsonl`);
+}
+function parseEvents(content) {
+    const events = [];
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (value &&
+                value.schemaVersion === 1 &&
+                typeof value.configId === "string" &&
+                typeof value.sessionId === "string" &&
+                typeof value.timestamp === "string" &&
+                value.event) {
+                events.push(value);
+            }
+        }
+        catch {
+            // Ignore malformed lines without discarding other valid events.
+        }
+    }
+    return events;
+}
+function readFileEvents(path) {
+    try {
+        return parseEvents(readFileSync(path, "utf8"));
+    }
+    catch {
+        return [];
+    }
+}
+function collectJsonlFiles(directory) {
+    if (!existsSync(directory))
+        return [];
+    const files = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory())
+            files.push(...collectJsonlFiles(path));
+        else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+            files.push(path);
+    }
+    return files;
+}
+/** Migrate the old shared file once, preserving an archive and avoiding duplicate lines. */
+export function migrateLegacyTelemetry() {
+    if (!existsSync(LEGACY_TELEMETRY_FILE))
+        return;
+    const legacyEvents = readFileEvents(LEGACY_TELEMETRY_FILE);
+    mkdirSync(TELEMETRY_DIRECTORY, { recursive: true, mode: 0o700 });
+    const groups = new Map();
+    for (const event of legacyEvents) {
+        const path = telemetrySessionPath(event.configId, event.sessionId);
+        const group = groups.get(path) ?? [];
+        group.push(event);
+        groups.set(path, group);
+    }
+    for (const [path, events] of groups) {
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        let existing = new Set();
+        try {
+            existing = new Set(readFileSync(path, "utf8").split("\n").filter(Boolean));
+        }
+        catch {
+            // New session file.
+        }
+        const missing = events
+            .map((event) => JSON.stringify(event))
+            .filter((line) => {
+            if (existing.has(line))
+                return false;
+            existing.add(line);
+            return true;
+        });
+        if (missing.length) {
+            appendFileSync(path, `${missing.join("\n")}\n`, { encoding: "utf8", mode: 0o600 });
+            chmodSync(path, 0o600);
+        }
+    }
+    let archive = LEGACY_ARCHIVE_FILE;
+    if (existsSync(archive))
+        archive = `${LEGACY_ARCHIVE_FILE}.${Date.now()}`;
+    renameSync(LEGACY_TELEMETRY_FILE, archive);
+}
+export function readAllTelemetryEvents() {
+    migrateLegacyTelemetry();
+    return collectJsonlFiles(TELEMETRY_DIRECTORY)
+        .flatMap(readFileEvents)
+        .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+export function resetTelemetry(profile, all = false) {
+    if (all) {
+        rmSync(TELEMETRY_DIRECTORY, { recursive: true, force: true });
+        rmSync(LEGACY_TELEMETRY_FILE, { force: true });
+        rmSync(LEGACY_ARCHIVE_FILE, { force: true });
+        for (const entry of existsSync(CONFIG_DIRECTORY)
+            ? readdirSync(CONFIG_DIRECTORY, { withFileTypes: true })
+            : []) {
+            if (entry.isFile() && entry.name.startsWith("telemetry.legacy-archive.jsonl.")) {
+                rmSync(join(CONFIG_DIRECTORY, entry.name), { force: true });
+            }
+        }
+        return;
+    }
+    if (!profile)
+        throw new Error("Specify a profile name or use --all.");
+    rmSync(join(TELEMETRY_DIRECTORY, safeSegment(profile)), { recursive: true, force: true });
+}
+export function ensureTelemetryDirectory() {
+    mkdirSync(TELEMETRY_DIRECTORY, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(TELEMETRY_DIRECTORY, 0o700);
+    }
+    catch {
+        // Best-effort permission hardening.
+    }
+}

package/dist/src/telemetry/types.d.ts

@@ -22,9 +22,27 @@ export interface TelemetryMcpRequestEvent {
     durationMs: number;
     errorCategory?: string;
 }
+export interface TelemetryFileMetric {
+    pathHash: string;
+    contentHash?: string;
+    bytes: number;
+}
 export interface TelemetryToolEvent {
     event: "tool_call";
     tool: string;
+    requestIdHash?: string;
+    inputFingerprint?: string;
+    outputFingerprint?: string;
+    /** Full local-only troubleshooting payload, emitted only at diagnostic level. */
+    diagnosticDetails?: Record<string, unknown>;
+    estimatedInputTokens?: number;
+    estimatedOutputTokens?: number;
+    cumulativeOutputBytes?: number;
+    cumulativeEstimatedOutputTokens?: number;
+    duplicateOutputBytes?: number;
+    textOutputBytes?: number;
+    uniqueFileCount?: number;
+    files?: TelemetryFileMetric[];
     success: boolean;
     durationMs: number;
     inputBytes?: number;
@@ -71,6 +89,10 @@ export interface TelemetryRuntimeContext {
     mcpClientName?: string;
     mcpClientVersion?: string;
     nodeVersion?: string;
+    distroId?: string;
+    distroName?: string;
+    distroVersion?: string;
+    kernelVersion?: string;
     hostname?: string;
     username?: string;
     processId?: number;

package/dist/src/tools/code.js

@@ -142,7 +142,7 @@ export function findReferences(root, symbol, maxResults = 200, maxBytes = DEFAUL
     return searchCode(root, `\\b${escaped}\\b`, true, maxResults, maxBytes);
 }
 export async function findImports(root, maxResults = 200, maxBytes = DEFAULT_OUTPUT_BYTES) {
-    const matches = await readMatches(root, String.raw `(?:^|[;{}])\\s*import(?:[^"'\\n]*?from\\s*)?["']([^"']+)["']|require\\(\\s*["']([^"']+)["']\\s*\\)`, { codeOnly: true, regex: true, maxResults });
+    const matches = await readMatches(root, String.raw `(?:^|[;{}])\s*import\s*(?:[^"'\n]*?from\s*)?["']([^"']+)["']|require\(\s*["']([^"']+)["']\s*\)`, { codeOnly: true, regex: true, maxResults });
     return boundMatches(matches.map((match) => {
         const captured = match.text.match(/(?:from\s*)?["']([^"']+)["']|require\(\s*["']([^"']+)["']\s*\)/);
         return {