e2e 0.15.2 → 0.17.0

package/dist/run/steps.js

@@ -1,6 +1,7 @@
 /** Attempt-scoped step timeline. */
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { isAgentError } from '../agent/error.js';
+import { markAbandonedRejection, relocateStack } from '../internal/abandoned.js';
 import { withAiTraceStep } from '../internal/ai-trace.js';
 import { classifyError, serializeError, TestError, withHint } from '../internal/errors.js';
 import { timestamp } from '../internal/ids.js';
@@ -9,16 +10,6 @@ import { sourceLocation } from '../internal/source.js';
 export const STEP_KINDS = ['agent', 'locator', 'assertion', 'screen', 'app', 'session', 'resource'];
 /** Frames kept when a step captures where it was called from; the user's line is a few frames up. */
 const STEP_STACK_FRAMES = 20;
-/** What abandoned steps rejected with. The promise the test holds rejects with the same value, and nobody awaits it. */
-const ABANDONED_REJECTIONS = new WeakSet();
-/**
- * Whether an unhandled rejection is an abandoned step's: already recorded as
- * `STEP_NOT_AWAITED`, reaching the process only because the promise the
- * test did not await rejected with it. Such a rejection is not a fault.
- */
-export function isAbandonedStepRejection(cause) {
-    return typeof cause === 'object' && cause !== null && ABANDONED_REJECTIONS.has(cause);
-}
 /**
  * The stack at a step's start, or nothing without a project root to read it
  * against. Every step pays the capture, since the failing one is not known
@@ -38,13 +29,6 @@ function stepStack(projectRoot) {
         Error.stackTraceLimit = limit;
     }
 }
-/** Points `error` at the frames of `stack`, keeping its own name and message as the first line. */
-function relocate(error, stack) {
-    if (stack === undefined)
-        return;
-    const frames = stack.split('\n').slice(1).join('\n');
-    error.stack = `${error.name}: ${error.message}\n${frames}`;
-}
 /** Characters of a step label an error message quotes before clipping it. */
 const MAX_QUOTED_LABEL_CHARS = 80;
 function quoted(label) {
@@ -92,7 +76,10 @@ export class StepRecorder {
         return this.lastVerified;
     }
     /** Runs one public API call as a recorded top-level step. */
-    run(kind, api, label, body, options = {}) {
+    run(kind, api, rawLabel, body, options = {}) {
+        // The label is published, reported, and traced as is: a secret the test
+        // spelled into an instruction or a locator stops here, once.
+        const label = this.redact?.(rawLabel) ?? rawLabel;
         const index = this.steps.length;
         const startedAt = timestamp();
         const stack = stepStack(this.projectRoot);
@@ -134,8 +121,7 @@ export class StepRecorder {
         }
         catch (cause) {
             if (this.abandoned.has(record.id)) {
-                if (typeof cause === 'object' && cause !== null)
-                    ABANDONED_REJECTIONS.add(cause);
+                markAbandonedRejection(cause);
                 throw cause;
             }
             record.durationMs = Date.now() - startedMs;
@@ -174,7 +160,7 @@ export class StepRecorder {
         for (const step of running) {
             const more = first === undefined && running.length > 1 ? ` and ${running.length - 1} more` : '';
             const error = new TestError('STEP_NOT_AWAITED', withHint(`the test body returned before ${step.api} ${quoted(step.label)}${more} finished`, 'put `await` in front of every step call'));
-            relocate(error, this.stacks.get(step.id));
+            relocateStack(error, this.stacks.get(step.id));
             first ??= error;
             this.abandoned.add(step.id);
             step.status = 'failed';
@@ -309,4 +295,3 @@ export class StepRecorder {
         });
     }
 }
-//# sourceMappingURL=steps.js.map

package/dist/run/trace-redaction.d.ts

@@ -22,4 +22,3 @@ import type { SecretLedger } from '../internal/redact.ts';
 export declare function redactTraceArchives(dir: string, paths: readonly string[], ledger: SecretLedger, options?: {
     readonly keepFrames?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=trace-redaction.d.ts.map

package/dist/run/trace-redaction.js

@@ -194,4 +194,3 @@ function decodeText(bytes) {
         return undefined;
     }
 }
-//# sourceMappingURL=trace-redaction.js.map

package/dist/run/unit-runner.d.ts

@@ -33,4 +33,3 @@ export interface UnitRunner {
  * device.
  */
 export type SpawnUnitRunner = (targetName: string, workerSlot: number, events: UnitRunnerEvents) => UnitRunner;
-//# sourceMappingURL=unit-runner.d.ts.map

package/dist/run/unit-runner.js

@@ -8,4 +8,3 @@
  * Keeping this interface narrow is what lets one scheduler own all execution.
  */
 export {};
-//# sourceMappingURL=unit-runner.js.map

package/dist/run/units.d.ts

@@ -74,4 +74,3 @@ export declare function nonRunResult(pair: TestTargetPair): ResultRecord;
 export declare function unstartedResult(pair: TestTargetPair, skip: SkipInfo): ResultRecord;
 /** Result for a test that vanished between planning and execution. */
 export declare function disappearedResult(pair: WirePair, target: ResolvedTarget): ResultRecord;
-//# sourceMappingURL=units.d.ts.map

package/dist/run/units.js

@@ -142,4 +142,3 @@ export function unstartedResult(pair, skip) {
 export function disappearedResult(pair, target) {
     return { test: pair.test, target, agent: pair.agent, repeat: pair.repeat, status: 'failed', selected: true, attempts: [] };
 }
-//# sourceMappingURL=units.js.map

package/dist/run/worker/entry.d.ts

@@ -5,4 +5,3 @@
  * actual execution to `TargetWorker`.
  */
 export {};
-//# sourceMappingURL=entry.d.ts.map

package/dist/run/worker/entry.js

@@ -14,10 +14,10 @@ import { AiTraceRecorder, registerAiTraceRecorder } from '../../internal/ai-trac
 import { DebugTrace } from '../../internal/debug.js';
 import { classifyError, ConfigurationError, serializeError } from '../../internal/errors.js';
 import { StreamRedactor } from '../../internal/redact.js';
-import { processSecrets, registerStaticSecrets } from '../secrecy.js';
+import { processSecrets, registerStaticSecrets, staticSecretLedger } from '../secrecy.js';
 import { SessionStore } from '../sessions.js';
 import { TargetWorker } from './session.js';
-import { isAbandonedStepRejection } from '../steps.js';
+import { isAbandonedRejection } from '../../internal/abandoned.js';
 /**
  * Outbound messages in flight. `process.send` is asynchronous and a
  * `process.exit` right behind it can drop the message, so exiting waits for
@@ -131,7 +131,7 @@ async function bootstrap(message, debug, aiTrace) {
     let collectCounter = 0;
     const resolvePairs = async (unit) => {
         collectCounter += 1;
-        const registration = await collectModule(() => importModule(unit.absolutePath, `worker-collect-${collectCounter}`), unit.absolutePath);
+        const registration = await collectModule(() => importModule(unit.absolutePath, `worker-collect-${collectCounter}`), unit.absolutePath, staticSecretLedger(config.allSecrets).redact);
         const collected = collectFromRegistration(config.projectRoot, unit.absolutePath, registration);
         const byId = new Map(collected.tests.map((test) => [test.id, test]));
         const pairs = [];
@@ -152,6 +152,7 @@ async function bootstrap(message, debug, aiTrace) {
         sessionStore: SessionStore.forWorker(message.runId, message.sessionsRoot, Buffer.from(message.sessionKeyBase64, 'base64')),
         runId: message.runId,
         artifactsRoot: message.artifactsRoot,
+        rerunDir: message.rerunDir,
         headed: message.headed,
         workerSlot: message.workerSlot,
         env: process.env,
@@ -169,13 +170,13 @@ function main() {
     process.on('SIGINT', () => undefined);
     process.on('SIGTERM', () => undefined);
     process.on('uncaughtException', (cause) => fatal(cause));
-    // A step the body did not await rejects on a promise nobody holds once it
-    // is cancelled; the attempt has already recorded it as STEP_NOT_AWAITED.
+    // A step or poll the test did not await rejects on a promise nobody holds
+    // once it is cancelled; the attempt has already recorded it as STEP_NOT_AWAITED.
     // Any other rejection nobody caught is charged to the attempt in flight,
     // or recorded against the last test that finished; only before any test
     // has finished is it the worker's.
     process.on('unhandledRejection', (cause) => {
-        if (isAbandonedStepRejection(cause))
+        if (isAbandonedRejection(cause))
             return;
         if (worker?.strayRejection(cause) !== true)
             fatal(cause);
@@ -229,4 +230,3 @@ function main() {
     });
 }
 main();
-//# sourceMappingURL=entry.js.map

package/dist/run/worker/handle.d.ts

@@ -8,4 +8,3 @@ export type ChildProcessSpawnOptions = Omit<WorkerBootstrap, 'targetName' | 'wor
 };
 /** Creates the spawn factory the scheduler uses for child-process execution. */
 export declare function childProcessSpawner(options: ChildProcessSpawnOptions): SpawnUnitRunner;
-//# sourceMappingURL=handle.d.ts.map

package/dist/run/worker/handle.js

@@ -73,4 +73,3 @@ class ChildProcessRunner {
             this.child.kill('SIGKILL');
     }
 }
-//# sourceMappingURL=handle.js.map

package/dist/run/worker/protocol.d.ts

@@ -56,6 +56,8 @@ export interface WorkerBootstrap {
     readonly workerSlot: number;
     readonly runId: string;
     readonly artifactsRoot: string;
+    /** See `TargetExecutorOptions.rerunDir`. */
+    readonly rerunDir: string | undefined;
     readonly headed: boolean;
     readonly sessionsRoot: string;
     /** Per-run AES key; transferred only over this channel, never disk or env. */
@@ -209,4 +211,3 @@ export interface RunAbortMessage {
 export type WorkerToMain = ReadyMessage | PairStartMessage | ProgressMessage | OutputMessage | NoticeMessage | ResultMessage | SerialGroupMessage | UnitDoneMessage | ShutdownDoneMessage | FatalMessage | RunAbortMessage;
 /** Reattaches the scheduler's resolved target to a wire result. */
 export declare function decodeResult(wire: WireResultRecord, target: ResolvedTarget): ResultRecord;
-//# sourceMappingURL=protocol.d.ts.map

package/dist/run/worker/protocol.js

@@ -10,4 +10,3 @@
 export function decodeResult(wire, target) {
     return { ...wire, target };
 }
-//# sourceMappingURL=protocol.js.map

package/dist/run/worker/session.d.ts

@@ -35,6 +35,8 @@ export interface TargetWorkerDeps {
     readonly sessionStore: SessionStore;
     readonly runId: string;
     readonly artifactsRoot: string;
+    /** See `TargetExecutorOptions.rerunDir`. */
+    readonly rerunDir: string | undefined;
     readonly headed: boolean;
     /** See `TargetExecutorOptions.workerSlot`. */
     readonly workerSlot: number;
@@ -114,4 +116,3 @@ export declare class TargetWorker {
     private shutdown;
     private disposeAndFinish;
 }
-//# sourceMappingURL=session.d.ts.map

package/dist/run/worker/session.js

@@ -46,6 +46,7 @@ export class TargetWorker {
                 target: deps.target,
                 runId: deps.runId,
                 artifactsRoot: deps.artifactsRoot,
+                rerunDir: deps.rerunDir,
                 sessionStore: deps.sessionStore,
                 headed: deps.headed,
                 workerSlot: deps.workerSlot,
@@ -206,4 +207,3 @@ export class TargetWorker {
         this.host.finished();
     }
 }
-//# sourceMappingURL=session.js.map

package/dist/run/worker-models.d.ts

@@ -25,4 +25,3 @@ export declare class WorkerModels {
     /** Adapter for one resolved model; each distinct model is built once per worker. A missing one names the agent `name`. */
     readonly build: (model: ResolvedModel | undefined, name: string) => ModelAdapter;
 }
-//# sourceMappingURL=worker-models.d.ts.map

package/dist/run/worker-models.js

@@ -57,4 +57,3 @@ export class WorkerModels {
 function modelKey(model) {
     return model.model;
 }
-//# sourceMappingURL=worker-models.js.map

package/dist/secrets.d.ts

@@ -43,4 +43,3 @@ export declare function isSecret(value: unknown): value is Secret;
 export declare const credentials: Credentials;
 export declare const secrets: Secrets;
 export {};
-//# sourceMappingURL=secrets.d.ts.map

package/dist/secrets.js

@@ -121,4 +121,3 @@ export const secrets = {
         return secretHandle(resolved);
     },
 };
-//# sourceMappingURL=secrets.js.map

package/dist/telemetry/checkout.d.ts

@@ -10,4 +10,3 @@
  * so the marker is positive. A URL that is not a file counts as installed.
  */
 export declare function runsFromCheckout(moduleUrl: string): boolean;
-//# sourceMappingURL=checkout.d.ts.map

package/dist/telemetry/checkout.js

@@ -19,4 +19,3 @@ export function runsFromCheckout(moduleUrl) {
         return false;
     }
 }
-//# sourceMappingURL=checkout.js.map

package/dist/telemetry/environment.d.ts

@@ -55,4 +55,3 @@ export declare function collectEnvironment(options: {
         readonly versions: NodeJS.ProcessVersions;
     };
 }): TelemetryEnvironment;
-//# sourceMappingURL=environment.d.ts.map

package/dist/telemetry/environment.js

@@ -140,4 +140,3 @@ export function collectEnvironment(options) {
         e2e_version: options.version,
     };
 }
-//# sourceMappingURL=environment.js.map

package/dist/telemetry/events.d.ts

@@ -1,15 +1,19 @@
 /**
  * The events e2e sends, built from facts the CLI already holds. Every
  * property is a count, a duration, a version, or a short token. The builders
- * copy no title, file, URL, instruction, message, or stack out of the report;
- * the one look at a message, in `failure-kind.ts`, yields a token from a
- * closed list.
- * The names a project declares for its engines, platforms, and model pass
- * through when they are plain tokens, so a homegrown engine counts as itself;
- * a name shaped like a path, a URL, or a sentence folds to `other`, and an
- * error code that is not an upper-case token, the shape of every runner
- * code, folds to `OTHER`. The unit tests hold the payload to that promise.
+ * copy no title, file, URL, instruction, message, or stack out of the report,
+ * the config, or an MCP session; the one look at a message, in
+ * `failure-kind.ts`, yields a token from a closed list.
+ * The names a project declares for its engines, platforms, and model, and the
+ * name an MCP client gives itself, pass through when they are plain tokens,
+ * so a homegrown engine counts as itself; a name shaped like a path, a URL,
+ * or a sentence folds to `other`, and an error code that is not an upper-case
+ * token, the shape of every runner code, folds to `OTHER`. The unit tests
+ * hold the payload to that promise.
  */
+import type { ResolvedConfig } from '../config/resolve.ts';
+import type { McpClient } from '../mcp/server.ts';
+import type { McpSessionSummary } from '../mcp/usage.ts';
 import type { Report1Document } from '../report/build.ts';
 import type { JsonValue } from '../types.ts';
 export interface TelemetryEvent {
@@ -24,6 +28,8 @@ export declare const EVENT_CLI_SESSION = "e2e_cli_session";
 export declare const EVENT_RUN_COMPLETED = "e2e_run_completed";
 /** One per `e2e init`, however it ended: what was chosen and whether anything was written. */
 export declare const EVENT_INIT_COMPLETED = "e2e_init_completed";
+/** One per `open_session` an `e2e mcp` server served, sent when the session closes or its open fails. */
+export declare const EVENT_MCP_SESSION = "e2e_mcp_session";
 /** The session's error code for a flag or argument commander rejected; no runner code exists for it. */
 export declare const USAGE_ERROR_CODE = "CLI_USAGE";
 /** How the invocation ended, known only once the command has returned or thrown. */
@@ -58,5 +64,15 @@ export interface InitOutcome {
 export declare function cliSessionEvent(command: string, flags: readonly string[], ended?: SessionEnd): TelemetryEvent;
 /** The init event: each choice as its option id. */
 export declare function initCompletedEvent(outcome: InitOutcome): TelemetryEvent;
-export declare function runCompletedEvent(report: Report1Document, flags: readonly string[]): TelemetryEvent;
-//# sourceMappingURL=events.d.ts.map
+/** What the CLI knows of a run beyond its report. */
+export interface RunContext {
+    /** `run` or `explore`. */
+    readonly command: string;
+    /** The flag names given, never their values. */
+    readonly flags: readonly string[];
+    /** The config the run resolved; undefined when it failed to load. */
+    readonly config: ResolvedConfig | undefined;
+}
+export declare function runCompletedEvent(report: Report1Document, context: RunContext): TelemetryEvent;
+/** One MCP session: the client, the target's platform and engine, how it ended, and its calls by the runner's tool names. */
+export declare function mcpSessionEvent(summary: McpSessionSummary, client: McpClient | undefined): TelemetryEvent;

package/dist/telemetry/events.js

@@ -1,16 +1,18 @@
 /**
  * The events e2e sends, built from facts the CLI already holds. Every
  * property is a count, a duration, a version, or a short token. The builders
- * copy no title, file, URL, instruction, message, or stack out of the report;
- * the one look at a message, in `failure-kind.ts`, yields a token from a
- * closed list.
- * The names a project declares for its engines, platforms, and model pass
- * through when they are plain tokens, so a homegrown engine counts as itself;
- * a name shaped like a path, a URL, or a sentence folds to `other`, and an
- * error code that is not an upper-case token, the shape of every runner
- * code, folds to `OTHER`. The unit tests hold the payload to that promise.
+ * copy no title, file, URL, instruction, message, or stack out of the report,
+ * the config, or an MCP session; the one look at a message, in
+ * `failure-kind.ts`, yields a token from a closed list.
+ * The names a project declares for its engines, platforms, and model, and the
+ * name an MCP client gives itself, pass through when they are plain tokens,
+ * so a homegrown engine counts as itself; a name shaped like a path, a URL,
+ * or a sentence folds to `other`, and an error code that is not an upper-case
+ * token, the shape of every runner code, folds to `OTHER`. The unit tests
+ * hold the payload to that promise.
  */
-import { GRAMMAR_ACTION_NAMES, PROJECT_TOOL_EVENT_PREFIX } from '../agent/action-names.js';
+import { GRAMMAR_ACTION_NAMES, GRAMMAR_TOOL_NAMES, PROJECT_TOOL_EVENT_PREFIX } from '../agent/action-names.js';
+import { modelLabel } from '../config/agent.js';
 import { STEP_KINDS } from '../run/steps.js';
 import { failureKind } from './failure-kind.js';
 import { errorCodeToken, plainToken } from './token.js';
@@ -20,6 +22,8 @@ export const EVENT_CLI_SESSION = 'e2e_cli_session';
 export const EVENT_RUN_COMPLETED = 'e2e_run_completed';
 /** One per `e2e init`, however it ended: what was chosen and whether anything was written. */
 export const EVENT_INIT_COMPLETED = 'e2e_init_completed';
+/** One per `open_session` an `e2e mcp` server served, sent when the session closes or its open fails. */
+export const EVENT_MCP_SESSION = 'e2e_mcp_session';
 /** The session's error code for a flag or argument commander rejected; no runner code exists for it. */
 export const USAGE_ERROR_CODE = 'CLI_USAGE';
 const SEMVER = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u;
@@ -80,6 +84,10 @@ function engineLabel(engine) {
 function unique(values) {
     return [...new Set(values)].toSorted();
 }
+/** Counts keyed in sorted order, so equal counts serialize equally. */
+function sortedCounts(counts) {
+    return Object.fromEntries([...counts].toSorted());
+}
 /** Every scope the run recorded, across plain results and serial groups. */
 function* scopes(report) {
     for (const result of report.run.results)
@@ -117,7 +125,7 @@ function agentActions(steps) {
             counts.set(name, (counts.get(name) ?? 0) + 1);
         }
     }
-    return Object.fromEntries([...counts].toSorted());
+    return sortedCounts(counts);
 }
 /** Whether anyone priced the model calls: a gateway that did, nobody, or no calls to price. */
 function costSource(usage, modelCalls) {
@@ -129,7 +137,50 @@ function durationMs(startedAt, finishedAt) {
     const duration = Date.parse(finishedAt) - Date.parse(startedAt);
     return Number.isFinite(duration) ? Math.max(0, duration) : null;
 }
-export function runCompletedEvent(report, flags) {
+/**
+ * Which config features a run used: counts, booleans, and the runner's own
+ * option ids, never a name, a path, or a value the project wrote.
+ */
+function configFeatures(config) {
+    const agents = [...config.agents.values()];
+    return {
+        config_workers: config.workers,
+        config_retries: config.retries,
+        config_agents: config.agents.size,
+        config_custom_executor: agents.some((agent) => agent.executor !== undefined),
+        config_separate_judge: agents.some((agent) => agent.judge !== undefined && (agent.model === undefined || modelLabel(agent.judge) !== modelLabel(agent.model))),
+        config_project_tools: new Set(agents.flatMap((agent) => Object.keys(agent.tools))).size,
+        config_credentials: config.credentials.size,
+        config_secrets: config.secrets.size,
+        config_cache_mode: config.cache.mode,
+        config_cache_store: config.cache.store === undefined ? 'file' : 'custom',
+        config_cache_strict: config.cache.strict !== false,
+        config_reporters: unique(config.reporters),
+        config_custom_reporters: config.customReporters.length,
+        config_artifact_store: config.artifactStore !== undefined,
+        config_trace_modes: unique(config.targets.map((target) => target.trace.mode)),
+        config_video_modes: unique(config.targets.map((target) => target.video.mode)),
+        config_app_commands: config.targets.filter((target) => target.app.command !== undefined).length,
+        config_environments: unique(config.targets.map((target) => target.app.environment)),
+    };
+}
+const EXPLORE_STEP_STATUSES = ['passed', 'failed', 'blocked', 'exhausted'];
+const SEVERITIES = [1, 2, 3, 4, 5];
+/** What `e2e explore` was given and found, by count: never the goal, a step's charter, or a finding's words. */
+function exploreProperties(explore) {
+    return {
+        explore_ended: explore.ended,
+        explore_max_steps: explore.budgets.maxSteps,
+        explore_timeout_ms: explore.budgets.timeoutMs,
+        explore_steps: explore.steps.length,
+        ...Object.fromEntries(EXPLORE_STEP_STATUSES.map((status) => [`explore_steps_${status}`, explore.steps.filter((step) => step.status === status).length])),
+        explore_assessed: explore.summary !== undefined,
+        explore_issues: explore.findings.filter((finding) => finding.kind === 'issue').length,
+        explore_warnings: explore.findings.filter((finding) => finding.kind === 'warning').length,
+        explore_findings_by_severity: Object.fromEntries(SEVERITIES.map((severity) => [String(severity), explore.findings.filter((finding) => finding.severity === severity).length])),
+    };
+}
+export function runCompletedEvent(report, context) {
     const { run } = report;
     const recorded = [...scopes(report)];
     const steps = recorded.flatMap((scope) => scope.steps ?? []);
@@ -144,15 +195,17 @@ export function runCompletedEvent(report, flags) {
         name: EVENT_RUN_COMPLETED,
         at: run.finishedAt,
         properties: {
+            command: context.command,
             status: run.status,
             exit_code: run.exitCode,
             duration_ms: durationMs(run.startedAt, run.finishedAt),
-            flags: [...flags],
+            flags: [...context.flags],
             tests_discovered: run.summary.discovered,
             tests_selected: run.summary.selected,
             tests_executed: run.summary.executed,
             tests_passed: run.summary.passed,
             tests_failed: run.summary.failed,
+            tests_interrupted: run.summary.interrupted,
             tests_flaky: run.summary.flaky,
             tests_skipped: run.summary.skipped,
             attempts_total: attempts.reduce((total, count) => total + count, 0),
@@ -180,7 +233,49 @@ export function runCompletedEvent(report, flags) {
             primary_error_code: primary === undefined ? null : errorCodeToken(primary.code),
             error_codes: unique(errors.map((error) => errorCodeToken(error.code))).slice(0, MAX_ERROR_CODES),
             error_kinds: unique(errors.flatMap(failureKind)).slice(0, MAX_ERROR_CODES),
+            // A run whose config never loaded has no features to report.
+            ...(context.config === undefined ? {} : configFeatures(context.config)),
+            ...(run.explore === undefined ? {} : exploreProperties(run.explore)),
+        },
+    };
+}
+/**
+ * The catalog tools an MCP session serves itself, by name: the grammar and
+ * the session's own (`createSessionCatalog`). A project's tools arrive
+ * counted together; any name outside this set folds to `other`.
+ */
+const SESSION_TOOLS = new Set([...GRAMMAR_TOOL_NAMES, 'locate', 'start_recording', 'stop_recording']);
+/** One MCP session: the client, the target's platform and engine, how it ended, and its calls by the runner's tool names. */
+export function mcpSessionEvent(summary, client) {
+    const calls = new Map();
+    for (const [name, count] of summary.toolCalls) {
+        const key = SESSION_TOOLS.has(name) ? name : 'other';
+        calls.set(key, (calls.get(key) ?? 0) + count);
+    }
+    if (summary.projectToolCalls > 0)
+        calls.set('tool', summary.projectToolCalls);
+    const codes = new Map();
+    for (const [code, count] of summary.errorCodes) {
+        const key = errorCodeToken(code);
+        codes.set(key, (codes.get(key) ?? 0) + count);
+    }
+    return {
+        name: EVENT_MCP_SESSION,
+        properties: {
+            client: client === undefined ? null : plainToken(client.name),
+            client_version: client === undefined ? null : plainToken(client.version),
+            outcome: summary.outcome,
+            ended_by: summary.endedBy ?? null,
+            error_code: summary.openErrorCode === undefined ? null : errorCodeToken(summary.openErrorCode),
+            platform: summary.platform === undefined ? null : plainToken(summary.platform),
+            engine: summary.engine === undefined ? null : engineLabel(summary.engine),
+            headed: summary.headed,
+            duration_ms: Math.max(0, Math.round(summary.durationMs)),
+            sessions_open: summary.concurrent,
+            calls_total: [...calls.values()].reduce((total, count) => total + count, 0),
+            calls_failed: summary.failedCalls,
+            calls: sortedCounts(calls),
+            error_codes: sortedCounts(new Map([...codes].toSorted().slice(0, MAX_ERROR_CODES))),
         },
     };
 }
-//# sourceMappingURL=events.js.map

package/dist/telemetry/failure-kind.d.ts

@@ -13,4 +13,3 @@
 import type { ReportError } from '../report/build.ts';
 /** `CODE:kind` for an error whose code only says where it surfaced; nothing for every other code. */
 export declare function failureKind(error: ReportError): string[];
-//# sourceMappingURL=failure-kind.d.ts.map

package/dist/telemetry/failure-kind.js

@@ -41,4 +41,3 @@ export function failureKind(error) {
     const kind = FAILURE_KINDS.find(([, pattern]) => pattern.test(error.message))?.[0] ?? 'other';
     return [`${error.code}:${kind}`];
 }
-//# sourceMappingURL=failure-kind.js.map

package/dist/telemetry/posthog.d.ts

@@ -30,4 +30,3 @@ export interface PostBatchOptions {
 }
 /** Sends the batch; resolves to whether PostHog accepted it. */
 export declare function postBatch(events: readonly PostHogEvent[], options: PostBatchOptions): Promise<boolean>;
-//# sourceMappingURL=posthog.d.ts.map

package/dist/telemetry/posthog.js

@@ -26,4 +26,3 @@ export async function postBatch(events, options) {
         return false;
     }
 }
-//# sourceMappingURL=posthog.js.map

package/dist/telemetry/project.d.ts

@@ -15,4 +15,3 @@
  * working directory is not a project.
  */
 export declare function anonymousProjectId(projectRoot: string, salt: string | undefined): Promise<string | undefined>;
-//# sourceMappingURL=project.d.ts.map

package/dist/telemetry/project.js

@@ -39,4 +39,3 @@ export async function anonymousProjectId(projectRoot, salt) {
         return undefined;
     return sha256Hex(`path\n${salt}\n${projectRoot}`);
 }
-//# sourceMappingURL=project.js.map

package/dist/telemetry/store.d.ts

@@ -55,4 +55,3 @@ export declare class TelemetryStore {
     markNotified(version: number, at: string): void;
     private write;
 }
-//# sourceMappingURL=store.d.ts.map

package/dist/telemetry/store.js

@@ -163,4 +163,3 @@ export class TelemetryStore {
         }
     }
 }
-//# sourceMappingURL=store.js.map

package/dist/telemetry/telemetry.d.ts

@@ -4,8 +4,10 @@
  * One instance lives for one CLI invocation. Commands hand it events; at the
  * end of the invocation `flush` sends them in a single bounded request, so a
  * command never waits on telemetry for more than the flush budget and never
- * fails because of it. Telemetry is a CLI concern only: the runner never
- * constructs this class.
+ * fails because of it. A long-lived command (`e2e mcp`) sends what it has
+ * queued as it goes with `sendQueued`, so a client that kills it loses only
+ * what was still in progress. Telemetry is a CLI concern only: the runner
+ * never constructs this class.
  *
  * Off means off at every step. `E2E_TELEMETRY_DISABLED`, `DO_NOT_TRACK`, a
  * source checkout of the repository, an `e2e telemetry disable`, or a
@@ -26,7 +28,7 @@
 import { type TelemetryEvent } from './events.ts';
 import { anonymousProjectId } from './project.ts';
 /** Bumped when what is collected changes enough that the notice must show again. */
-export declare const NOTICE_VERSION = 2;
+export declare const NOTICE_VERSION = 3;
 export type TelemetryDisabledBy = 'E2E_TELEMETRY_DISABLED' | 'DO_NOT_TRACK' | 'checkout' | 'preference' | 'store';
 export interface TelemetryOptions {
     /** The e2e version, sent with every event. */
@@ -66,6 +68,8 @@ export declare class Telemetry {
     private command;
     private failure;
     private exitCode;
+    /** Sends `sendQueued` started that have not settled; the flush waits for them. */
+    private readonly sending;
     constructor(options: TelemetryOptions);
     /** Opened on first use, so `--version` and `--help` never touch the disk; undefined when the file cannot exist. */
     private store;
@@ -117,11 +121,18 @@ export declare class Telemetry {
     /** The session event, first in the batch; absent for an invocation that never reached a command. */
     private sessionEvent;
     /**
-     * Sends everything queued in one request, or prints it under debug. One
-     * deadline covers the project lookup still running and the request; a
-     * lost batch is the accepted cost of a command that never waits on
-     * telemetry.
+     * Sends everything queued in one request, or prints it under debug, and
+     * waits for the sends `sendQueued` started. One deadline covers the
+     * project lookup still running and the request; a lost batch is the
+     * accepted cost of a command that never waits on telemetry.
      */
     flush(maxWaitMs?: number): Promise<void>;
+    /**
+     * Sends what is queued now, without the session event, which only the
+     * flush at the end can complete. For a command that runs until its client
+     * goes away; the caller need not wait, the flush does.
+     */
+    sendQueued(maxWaitMs?: number): Promise<void>;
+    /** Sends `events` in one bounded request, or prints them under debug; nothing when off. */
+    private send;
 }
-//# sourceMappingURL=telemetry.d.ts.map