@testchimp/cli 0.1.10 → 0.1.12

package/dist/cli/program.d.ts

@@ -1,3 +1,4 @@
 import { Command } from "commander";
-export declare const PACKAGE_VERSION = "0.1.7";
+import { PACKAGE_VERSION } from "../core/version.js";
+export { PACKAGE_VERSION };
 export declare function buildCliProgram(): Command;

package/dist/cli/program.js

@@ -5,7 +5,8 @@ import { DEFAULT_BACKEND, postMcp } from "../core/client.js";
 import { deepMerge } from "../core/merge.js";
 import { runTool } from "../core/tools.js";
 import { TOOL_DEFINITIONS } from "../core/tools.js";
-export const PACKAGE_VERSION = "0.1.7";
+import { PACKAGE_VERSION } from "../core/version.js";
+export { PACKAGE_VERSION };
 function parseRecordTypesCsv(raw) {
     return String(raw)
         .split(",")
@@ -58,6 +59,29 @@ export function buildCliProgram() {
     function jsonInputOption() {
         return new Option("--json-input <json>", "Advanced: JSON object or @path; merged over flags (JSON wins on conflicts)");
     }
+    /** Seed a minimal ExecutionScope from common flags (JSON can override / extend). */
+    function scopeFromFlags(opts) {
+        const scope = {};
+        if (opts.environment)
+            scope.environment = String(opts.environment);
+        if (opts.relativeWindow)
+            scope.timeWindow = { relativeWindow: String(opts.relativeWindow) };
+        if (opts.platform)
+            scope.platform = String(opts.platform);
+        if (opts.release)
+            scope.release = String(opts.release);
+        if (opts.branchName)
+            scope.branchName = String(opts.branchName);
+        return Object.keys(scope).length > 0 ? scope : undefined;
+    }
+    function addTruecoverageScopeFlags(cmd) {
+        return cmd
+            .option("--environment <s>", "RUM environment tag (seeds base scope)")
+            .option("--relative-window <duration>", 'Duration string ending in s, e.g. 604800s (seeds base scope timeWindow)')
+            .option("--platform <web|ios|android>", "Platform filter on base scope (aliases or WEB_/IOS_/ANDROID_EXECUTION_PLATFORM)")
+            .option("--release <s>", "Optional release filter on base scope")
+            .option("--branch-name <s>", "Optional branchName on base scope");
+    }
     program
         .command("get-requirement-coverage")
         .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-requirement-coverage").description)
@@ -420,49 +444,81 @@ export function buildCliProgram() {
         const out = await runTool("list-rum-environments", merged, { postMcp });
         console.log(out);
     });
-    const truecoverageHelp = "Use --json-input with full request JSON (proto-shaped; set platform inside each ExecutionScope).";
-    program
+    addTruecoverageScopeFlags(program
         .command("get-truecoverage-events")
-        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-events").description + " " + truecoverageHelp)
-        .addOption(jsonInputOption())
-        .action(async (opts) => {
-        const merged = mergeBodies({}, opts.jsonInput);
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-events").description)
+        .addOption(jsonInputOption())).action(async (opts) => {
+        const body = {};
+        const base = scopeFromFlags(opts);
+        if (base)
+            body.baseExecutionScope = base;
+        const merged = mergeBodies(body, opts.jsonInput);
         const out = await runTool("get-truecoverage-events", merged, { postMcp });
         console.log(out);
     });
-    program
+    addTruecoverageScopeFlags(program
         .command("get-truecoverage-event-details")
-        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-event-details").description + " " + truecoverageHelp)
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-event-details").description)
         .addOption(jsonInputOption())
-        .action(async (opts) => {
-        const merged = mergeBodies({}, opts.jsonInput);
+        .option("--event-title <title>", "Event title (or set eventTitle in --json-input)")).action(async (opts) => {
+        const body = {};
+        if (opts.eventTitle)
+            body.eventTitle = String(opts.eventTitle);
+        const base = scopeFromFlags(opts);
+        if (base)
+            body.baseExecutionScope = base;
+        const merged = mergeBodies(body, opts.jsonInput);
         const out = await runTool("get-truecoverage-event-details", merged, { postMcp });
         console.log(out);
     });
-    program
+    addTruecoverageScopeFlags(program
         .command("get-truecoverage-child-event-tree")
-        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-child-event-tree").description + " " + truecoverageHelp)
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-child-event-tree").description)
         .addOption(jsonInputOption())
-        .action(async (opts) => {
-        const merged = mergeBodies({}, opts.jsonInput);
+        .option("--event-title <title>", "Parent event title (or set eventTitle in --json-input)")).action(async (opts) => {
+        const body = {};
+        if (opts.eventTitle)
+            body.eventTitle = String(opts.eventTitle);
+        const base = scopeFromFlags(opts);
+        if (base)
+            body.baseScope = base;
+        const merged = mergeBodies(body, opts.jsonInput);
         const out = await runTool("get-truecoverage-child-event-tree", merged, { postMcp });
         console.log(out);
     });
-    program
+    addTruecoverageScopeFlags(program
         .command("get-truecoverage-event-transition")
-        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-event-transition").description + " " + truecoverageHelp)
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-event-transition").description)
         .addOption(jsonInputOption())
-        .action(async (opts) => {
-        const merged = mergeBodies({}, opts.jsonInput);
+        .option("--event-title <title>", "From event (or eventTitle in --json-input)")
+        .option("--next-event-title <title>", "To event (or nextEventTitle in --json-input)")).action(async (opts) => {
+        const body = {};
+        if (opts.eventTitle)
+            body.eventTitle = String(opts.eventTitle);
+        if (opts.nextEventTitle)
+            body.nextEventTitle = String(opts.nextEventTitle);
+        const base = scopeFromFlags(opts);
+        if (base)
+            body.baseScope = base;
+        const merged = mergeBodies(body, opts.jsonInput);
         const out = await runTool("get-truecoverage-event-transition", merged, { postMcp });
         console.log(out);
     });
-    program
+    addTruecoverageScopeFlags(program
         .command("get-truecoverage-event-time-series")
-        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-event-time-series").description + " " + truecoverageHelp)
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-event-time-series").description)
         .addOption(jsonInputOption())
-        .action(async (opts) => {
-        const merged = mergeBodies({}, opts.jsonInput);
+        .option("--event-title <title>", "Optional event title")
+        .option("--metric-type <name>", "SESSION_COUNT | RELATIVE_FREQUENCY | PERCENTAGE_TERMINAL_EVENT | SESSION_POSITION | …")).action(async (opts) => {
+        const body = {};
+        if (opts.eventTitle)
+            body.eventTitle = String(opts.eventTitle);
+        if (opts.metricType)
+            body.metricType = String(opts.metricType);
+        const base = scopeFromFlags(opts);
+        if (base)
+            body.baseExecutionScope = base;
+        const merged = mergeBodies(body, opts.jsonInput);
         const out = await runTool("get-truecoverage-event-time-series", merged, { postMcp });
         console.log(out);
     });
@@ -479,9 +535,11 @@ export function buildCliProgram() {
         .command("get-truecoverage-event-metadata-keys")
         .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-truecoverage-event-metadata-keys").description)
         .addOption(jsonInputOption())
-        .requiredOption("--event-title <title>")
+        .option("--event-title <title>", "Event title (or set eventTitle in --json-input)")
         .action(async (opts) => {
-        const body = { eventTitle: opts.eventTitle };
+        const body = {};
+        if (opts.eventTitle)
+            body.eventTitle = String(opts.eventTitle);
         const merged = mergeBodies(body, opts.jsonInput);
         const out = await runTool("get-truecoverage-event-metadata-keys", merged, { postMcp });
         console.log(out);

package/dist/core/schemas.d.ts

@@ -83,7 +83,449 @@ export declare const emptyInput: z.ZodObject<{}, z.core.$strip>;
 export declare const getBranchSpecificEndpointConfigInput: z.ZodObject<{
     branchName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export declare const truecoverageJsonInput: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/** TimeWindow oneof — exactly one branch (union exposes clearly to MCP agents). */
+export declare const timeWindowSchema: z.ZodUnion<readonly [z.ZodObject<{
+    relativeWindow: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    fixedWindow: z.ZodObject<{
+        startTime: z.ZodString;
+        endTime: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>]>;
+/**
+ * ExecutionScope (rum_service.proto) — wire shape for Protobuf JsonFormat.
+ * Window must be nested under timeWindow (canonical). Flat relativeWindow on the scope is not accepted here.
+ */
+export declare const executionScopeSchema: z.ZodObject<{
+    environment: z.ZodString;
+    timeWindow: z.ZodUnion<readonly [z.ZodObject<{
+        relativeWindow: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        fixedWindow: z.ZodObject<{
+            startTime: z.ZodString;
+            endTime: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>]>;
+    release: z.ZodOptional<z.ZodString>;
+    branchName: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+        web: "web";
+        ios: "ios";
+        android: "android";
+        UNKNOWN_EXECUTION_PLATFORM: "UNKNOWN_EXECUTION_PLATFORM";
+        WEB_EXECUTION_PLATFORM: "WEB_EXECUTION_PLATFORM";
+        IOS_EXECUTION_PLATFORM: "IOS_EXECUTION_PLATFORM";
+        ANDROID_EXECUTION_PLATFORM: "ANDROID_EXECUTION_PLATFORM";
+    }>, z.ZodTransform<"UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM", "web" | "ios" | "android" | "UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM">>>;
+    automationEmitsOnly: z.ZodOptional<z.ZodBoolean>;
+    metadataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodObject<{
+            stringValue: z.ZodOptional<z.ZodString>;
+            intValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            floatValue: z.ZodOptional<z.ZodNumber>;
+            boolValue: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        operator: z.ZodOptional<z.ZodEnum<{
+            UNKNOWN_OPERATOR: "UNKNOWN_OPERATOR";
+            EQUALS: "EQUALS";
+            NOT_EQUALS: "NOT_EQUALS";
+            GREATER_THAN: "GREATER_THAN";
+            LESS_THAN: "LESS_THAN";
+        }>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const listTruecoverageEventsInput: z.ZodObject<{
+    baseExecutionScope: z.ZodObject<{
+        environment: z.ZodString;
+        timeWindow: z.ZodUnion<readonly [z.ZodObject<{
+            relativeWindow: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            fixedWindow: z.ZodObject<{
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strict>]>;
+        release: z.ZodOptional<z.ZodString>;
+        branchName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+            web: "web";
+            ios: "ios";
+            android: "android";
+            UNKNOWN_EXECUTION_PLATFORM: "UNKNOWN_EXECUTION_PLATFORM";
+            WEB_EXECUTION_PLATFORM: "WEB_EXECUTION_PLATFORM";
+            IOS_EXECUTION_PLATFORM: "IOS_EXECUTION_PLATFORM";
+            ANDROID_EXECUTION_PLATFORM: "ANDROID_EXECUTION_PLATFORM";
+        }>, z.ZodTransform<"UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM", "web" | "ios" | "android" | "UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM">>>;
+        automationEmitsOnly: z.ZodOptional<z.ZodBoolean>;
+        metadataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodObject<{
+                stringValue: z.ZodOptional<z.ZodString>;
+                intValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                floatValue: z.ZodOptional<z.ZodNumber>;
+                boolValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            operator: z.ZodOptional<z.ZodEnum<{
+                UNKNOWN_OPERATOR: "UNKNOWN_OPERATOR";
+                EQUALS: "EQUALS";
+                NOT_EQUALS: "NOT_EQUALS";
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    comparisonExecutionScope: z.ZodOptional<z.ZodObject<{
+        environment: z.ZodString;
+        timeWindow: z.ZodUnion<readonly [z.ZodObject<{
+            relativeWindow: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            fixedWindow: z.ZodObject<{
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strict>]>;
+        release: z.ZodOptional<z.ZodString>;
+        branchName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+            web: "web";
+            ios: "ios";
+            android: "android";
+            UNKNOWN_EXECUTION_PLATFORM: "UNKNOWN_EXECUTION_PLATFORM";
+            WEB_EXECUTION_PLATFORM: "WEB_EXECUTION_PLATFORM";
+            IOS_EXECUTION_PLATFORM: "IOS_EXECUTION_PLATFORM";
+            ANDROID_EXECUTION_PLATFORM: "ANDROID_EXECUTION_PLATFORM";
+        }>, z.ZodTransform<"UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM", "web" | "ios" | "android" | "UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM">>>;
+        automationEmitsOnly: z.ZodOptional<z.ZodBoolean>;
+        metadataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodObject<{
+                stringValue: z.ZodOptional<z.ZodString>;
+                intValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                floatValue: z.ZodOptional<z.ZodNumber>;
+                boolValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            operator: z.ZodOptional<z.ZodEnum<{
+                UNKNOWN_OPERATOR: "UNKNOWN_OPERATOR";
+                EQUALS: "EQUALS";
+                NOT_EQUALS: "NOT_EQUALS";
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const getTruecoverageEventDetailsInput: z.ZodObject<{
+    eventTitle: z.ZodString;
+    baseExecutionScope: z.ZodObject<{
+        environment: z.ZodString;
+        timeWindow: z.ZodUnion<readonly [z.ZodObject<{
+            relativeWindow: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            fixedWindow: z.ZodObject<{
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strict>]>;
+        release: z.ZodOptional<z.ZodString>;
+        branchName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+            web: "web";
+            ios: "ios";
+            android: "android";
+            UNKNOWN_EXECUTION_PLATFORM: "UNKNOWN_EXECUTION_PLATFORM";
+            WEB_EXECUTION_PLATFORM: "WEB_EXECUTION_PLATFORM";
+            IOS_EXECUTION_PLATFORM: "IOS_EXECUTION_PLATFORM";
+            ANDROID_EXECUTION_PLATFORM: "ANDROID_EXECUTION_PLATFORM";
+        }>, z.ZodTransform<"UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM", "web" | "ios" | "android" | "UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM">>>;
+        automationEmitsOnly: z.ZodOptional<z.ZodBoolean>;
+        metadataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodObject<{
+                stringValue: z.ZodOptional<z.ZodString>;
+                intValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                floatValue: z.ZodOptional<z.ZodNumber>;
+                boolValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            operator: z.ZodOptional<z.ZodEnum<{
+                UNKNOWN_OPERATOR: "UNKNOWN_OPERATOR";
+                EQUALS: "EQUALS";
+                NOT_EQUALS: "NOT_EQUALS";
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    comparisonExecutionScope: z.ZodOptional<z.ZodObject<{
+        environment: z.ZodString;
+        timeWindow: z.ZodUnion<readonly [z.ZodObject<{
+            relativeWindow: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            fixedWindow: z.ZodObject<{
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strict>]>;
+        release: z.ZodOptional<z.ZodString>;
+        branchName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+            web: "web";
+            ios: "ios";
+            android: "android";
+            UNKNOWN_EXECUTION_PLATFORM: "UNKNOWN_EXECUTION_PLATFORM";
+            WEB_EXECUTION_PLATFORM: "WEB_EXECUTION_PLATFORM";
+            IOS_EXECUTION_PLATFORM: "IOS_EXECUTION_PLATFORM";
+            ANDROID_EXECUTION_PLATFORM: "ANDROID_EXECUTION_PLATFORM";
+        }>, z.ZodTransform<"UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM", "web" | "ios" | "android" | "UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM">>>;
+        automationEmitsOnly: z.ZodOptional<z.ZodBoolean>;
+        metadataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodObject<{
+                stringValue: z.ZodOptional<z.ZodString>;
+                intValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                floatValue: z.ZodOptional<z.ZodNumber>;
+                boolValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            operator: z.ZodOptional<z.ZodEnum<{
+                UNKNOWN_OPERATOR: "UNKNOWN_OPERATOR";
+                EQUALS: "EQUALS";
+                NOT_EQUALS: "NOT_EQUALS";
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const listTruecoverageChildEventTreeInput: z.ZodObject<{
+    eventTitle: z.ZodString;
+    baseScope: z.ZodObject<{
+        environment: z.ZodString;
+        timeWindow: z.ZodUnion<readonly [z.ZodObject<{
+            relativeWindow: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            fixedWindow: z.ZodObject<{
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strict>]>;
+        release: z.ZodOptional<z.ZodString>;
+        branchName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+            web: "web";
+            ios: "ios";
+            android: "android";
+            UNKNOWN_EXECUTION_PLATFORM: "UNKNOWN_EXECUTION_PLATFORM";
+            WEB_EXECUTION_PLATFORM: "WEB_EXECUTION_PLATFORM";
+            IOS_EXECUTION_PLATFORM: "IOS_EXECUTION_PLATFORM";
+            ANDROID_EXECUTION_PLATFORM: "ANDROID_EXECUTION_PLATFORM";
+        }>, z.ZodTransform<"UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM", "web" | "ios" | "android" | "UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM">>>;
+        automationEmitsOnly: z.ZodOptional<z.ZodBoolean>;
+        metadataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodObject<{
+                stringValue: z.ZodOptional<z.ZodString>;
+                intValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                floatValue: z.ZodOptional<z.ZodNumber>;
+                boolValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            operator: z.ZodOptional<z.ZodEnum<{
+                UNKNOWN_OPERATOR: "UNKNOWN_OPERATOR";
+                EQUALS: "EQUALS";
+                NOT_EQUALS: "NOT_EQUALS";
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    coverageScope: z.ZodOptional<z.ZodObject<{
+        environment: z.ZodString;
+        timeWindow: z.ZodUnion<readonly [z.ZodObject<{
+            relativeWindow: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            fixedWindow: z.ZodObject<{
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strict>]>;
+        release: z.ZodOptional<z.ZodString>;
+        branchName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+            web: "web";
+            ios: "ios";
+            android: "android";
+            UNKNOWN_EXECUTION_PLATFORM: "UNKNOWN_EXECUTION_PLATFORM";
+            WEB_EXECUTION_PLATFORM: "WEB_EXECUTION_PLATFORM";
+            IOS_EXECUTION_PLATFORM: "IOS_EXECUTION_PLATFORM";
+            ANDROID_EXECUTION_PLATFORM: "ANDROID_EXECUTION_PLATFORM";
+        }>, z.ZodTransform<"UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM", "web" | "ios" | "android" | "UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM">>>;
+        automationEmitsOnly: z.ZodOptional<z.ZodBoolean>;
+        metadataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodObject<{
+                stringValue: z.ZodOptional<z.ZodString>;
+                intValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                floatValue: z.ZodOptional<z.ZodNumber>;
+                boolValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            operator: z.ZodOptional<z.ZodEnum<{
+                UNKNOWN_OPERATOR: "UNKNOWN_OPERATOR";
+                EQUALS: "EQUALS";
+                NOT_EQUALS: "NOT_EQUALS";
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const getTruecoverageEventTransitionInput: z.ZodObject<{
+    eventTitle: z.ZodString;
+    nextEventTitle: z.ZodString;
+    baseScope: z.ZodObject<{
+        environment: z.ZodString;
+        timeWindow: z.ZodUnion<readonly [z.ZodObject<{
+            relativeWindow: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            fixedWindow: z.ZodObject<{
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strict>]>;
+        release: z.ZodOptional<z.ZodString>;
+        branchName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+            web: "web";
+            ios: "ios";
+            android: "android";
+            UNKNOWN_EXECUTION_PLATFORM: "UNKNOWN_EXECUTION_PLATFORM";
+            WEB_EXECUTION_PLATFORM: "WEB_EXECUTION_PLATFORM";
+            IOS_EXECUTION_PLATFORM: "IOS_EXECUTION_PLATFORM";
+            ANDROID_EXECUTION_PLATFORM: "ANDROID_EXECUTION_PLATFORM";
+        }>, z.ZodTransform<"UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM", "web" | "ios" | "android" | "UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM">>>;
+        automationEmitsOnly: z.ZodOptional<z.ZodBoolean>;
+        metadataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodObject<{
+                stringValue: z.ZodOptional<z.ZodString>;
+                intValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                floatValue: z.ZodOptional<z.ZodNumber>;
+                boolValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            operator: z.ZodOptional<z.ZodEnum<{
+                UNKNOWN_OPERATOR: "UNKNOWN_OPERATOR";
+                EQUALS: "EQUALS";
+                NOT_EQUALS: "NOT_EQUALS";
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    coverageScope: z.ZodOptional<z.ZodObject<{
+        environment: z.ZodString;
+        timeWindow: z.ZodUnion<readonly [z.ZodObject<{
+            relativeWindow: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            fixedWindow: z.ZodObject<{
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strict>]>;
+        release: z.ZodOptional<z.ZodString>;
+        branchName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+            web: "web";
+            ios: "ios";
+            android: "android";
+            UNKNOWN_EXECUTION_PLATFORM: "UNKNOWN_EXECUTION_PLATFORM";
+            WEB_EXECUTION_PLATFORM: "WEB_EXECUTION_PLATFORM";
+            IOS_EXECUTION_PLATFORM: "IOS_EXECUTION_PLATFORM";
+            ANDROID_EXECUTION_PLATFORM: "ANDROID_EXECUTION_PLATFORM";
+        }>, z.ZodTransform<"UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM", "web" | "ios" | "android" | "UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM">>>;
+        automationEmitsOnly: z.ZodOptional<z.ZodBoolean>;
+        metadataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodObject<{
+                stringValue: z.ZodOptional<z.ZodString>;
+                intValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                floatValue: z.ZodOptional<z.ZodNumber>;
+                boolValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            operator: z.ZodOptional<z.ZodEnum<{
+                UNKNOWN_OPERATOR: "UNKNOWN_OPERATOR";
+                EQUALS: "EQUALS";
+                NOT_EQUALS: "NOT_EQUALS";
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** EventTimeSeriesMetricType — must match rum_service.proto enum names. */
+export declare const eventTimeSeriesMetricSchema: z.ZodEnum<{
+    EVENT_TIME_SERIES_METRIC_UNSPECIFIED: "EVENT_TIME_SERIES_METRIC_UNSPECIFIED";
+    SESSION_COUNT: "SESSION_COUNT";
+    RELATIVE_FREQUENCY: "RELATIVE_FREQUENCY";
+    PERCENTAGE_TERMINAL_EVENT: "PERCENTAGE_TERMINAL_EVENT";
+    SESSION_POSITION: "SESSION_POSITION";
+    TIME_TO_NEXT_EVENT: "TIME_TO_NEXT_EVENT";
+    REVERSE_INDEX: "REVERSE_INDEX";
+    TIME_FROM_START: "TIME_FROM_START";
+    TIME_TO_END: "TIME_TO_END";
+    TIME_SINCE_PREVIOUS_EVENT: "TIME_SINCE_PREVIOUS_EVENT";
+}>;
+export declare const getTruecoverageEventTimeSeriesInput: z.ZodObject<{
+    baseExecutionScope: z.ZodObject<{
+        environment: z.ZodString;
+        timeWindow: z.ZodUnion<readonly [z.ZodObject<{
+            relativeWindow: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            fixedWindow: z.ZodObject<{
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strict>]>;
+        release: z.ZodOptional<z.ZodString>;
+        branchName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+            web: "web";
+            ios: "ios";
+            android: "android";
+            UNKNOWN_EXECUTION_PLATFORM: "UNKNOWN_EXECUTION_PLATFORM";
+            WEB_EXECUTION_PLATFORM: "WEB_EXECUTION_PLATFORM";
+            IOS_EXECUTION_PLATFORM: "IOS_EXECUTION_PLATFORM";
+            ANDROID_EXECUTION_PLATFORM: "ANDROID_EXECUTION_PLATFORM";
+        }>, z.ZodTransform<"UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM", "web" | "ios" | "android" | "UNKNOWN_EXECUTION_PLATFORM" | "WEB_EXECUTION_PLATFORM" | "IOS_EXECUTION_PLATFORM" | "ANDROID_EXECUTION_PLATFORM">>>;
+        automationEmitsOnly: z.ZodOptional<z.ZodBoolean>;
+        metadataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodObject<{
+                stringValue: z.ZodOptional<z.ZodString>;
+                intValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                floatValue: z.ZodOptional<z.ZodNumber>;
+                boolValue: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            operator: z.ZodOptional<z.ZodEnum<{
+                UNKNOWN_OPERATOR: "UNKNOWN_OPERATOR";
+                EQUALS: "EQUALS";
+                NOT_EQUALS: "NOT_EQUALS";
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    eventTitle: z.ZodOptional<z.ZodString>;
+    metricType: z.ZodOptional<z.ZodEnum<{
+        EVENT_TIME_SERIES_METRIC_UNSPECIFIED: "EVENT_TIME_SERIES_METRIC_UNSPECIFIED";
+        SESSION_COUNT: "SESSION_COUNT";
+        RELATIVE_FREQUENCY: "RELATIVE_FREQUENCY";
+        PERCENTAGE_TERMINAL_EVENT: "PERCENTAGE_TERMINAL_EVENT";
+        SESSION_POSITION: "SESSION_POSITION";
+        TIME_TO_NEXT_EVENT: "TIME_TO_NEXT_EVENT";
+        REVERSE_INDEX: "REVERSE_INDEX";
+        TIME_FROM_START: "TIME_FROM_START";
+        TIME_TO_END: "TIME_TO_END";
+        TIME_SINCE_PREVIOUS_EVENT: "TIME_SINCE_PREVIOUS_EVENT";
+    }>>;
+}, z.core.$strip>;
 export declare const eventMetadataKeysInput: z.ZodObject<{
     eventTitle: z.ZodString;
 }, z.core.$strip>;

package/dist/core/schemas.js

@@ -84,7 +84,125 @@ export const emptyInput = z.object({});
 export const getBranchSpecificEndpointConfigInput = z.object({
     branchName: z.string().optional(),
 });
-export const truecoverageJsonInput = z.record(z.string(), z.unknown());
+/** Protobuf JSON Duration — must end in `s`, e.g. "604800s", "1.5s". */
+const protobufDurationSchema = z
+    .string()
+    .regex(/^-?\d+(\.\d+)?s$/, 'Duration must be protobuf JSON ending in "s", e.g. "604800s"');
+const fixedWindowSchema = z
+    .object({
+    startTime: z.string().min(1).describe("RFC 3339 timestamp"),
+    endTime: z.string().min(1).describe("RFC 3339 timestamp"),
+})
+    .describe("Fixed calendar window (both bounds required)");
+/** TimeWindow oneof — exactly one branch (union exposes clearly to MCP agents). */
+export const timeWindowSchema = z.union([
+    z.object({ relativeWindow: protobufDurationSchema }).strict(),
+    z.object({ fixedWindow: fixedWindowSchema }).strict(),
+]);
+/** Accept CLI aliases (web|ios|android) or proto enum names; normalize to proto. */
+const executionScopePlatformSchema = z
+    .enum([
+    "web",
+    "ios",
+    "android",
+    "UNKNOWN_EXECUTION_PLATFORM",
+    "WEB_EXECUTION_PLATFORM",
+    "IOS_EXECUTION_PLATFORM",
+    "ANDROID_EXECUTION_PLATFORM",
+])
+    .transform((p) => {
+    switch (p) {
+        case "web":
+            return "WEB_EXECUTION_PLATFORM";
+        case "ios":
+            return "IOS_EXECUTION_PLATFORM";
+        case "android":
+            return "ANDROID_EXECUTION_PLATFORM";
+        default:
+            return p;
+    }
+});
+const typedValueSchema = z
+    .object({
+    stringValue: z.string().optional(),
+    /** Protobuf JSON often encodes int64 as string. */
+    intValue: z.union([z.string(), z.number()]).optional(),
+    floatValue: z.number().optional(),
+    boolValue: z.boolean().optional(),
+})
+    .superRefine((v, ctx) => {
+    const set = [v.stringValue, v.intValue, v.floatValue, v.boolValue].filter((x) => x !== undefined);
+    if (set.length !== 1) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "TypedValue requires exactly one of stringValue, intValue, floatValue, boolValue",
+        });
+    }
+});
+const metadataFilterSchema = z.object({
+    key: z.string().min(1),
+    value: typedValueSchema,
+    operator: z
+        .enum(["UNKNOWN_OPERATOR", "EQUALS", "NOT_EQUALS", "GREATER_THAN", "LESS_THAN"])
+        .optional(),
+});
+/**
+ * ExecutionScope (rum_service.proto) — wire shape for Protobuf JsonFormat.
+ * Window must be nested under timeWindow (canonical). Flat relativeWindow on the scope is not accepted here.
+ */
+export const executionScopeSchema = z.object({
+    environment: z
+        .string()
+        .min(1)
+        .describe("RUM environment tag from list-rum-environments (e.g. QA, production)"),
+    timeWindow: timeWindowSchema,
+    release: z.string().optional(),
+    branchName: z.string().optional(),
+    platform: executionScopePlatformSchema.optional(),
+    automationEmitsOnly: z
+        .boolean()
+        .optional()
+        .describe("On comparison/coverage scopes only: restrict to emits with test_id"),
+    metadataFilters: z.array(metadataFilterSchema).optional(),
+});
+export const listTruecoverageEventsInput = z.object({
+    baseExecutionScope: executionScopeSchema,
+    comparisonExecutionScope: executionScopeSchema.optional(),
+});
+export const getTruecoverageEventDetailsInput = z.object({
+    eventTitle: z.string().min(1),
+    baseExecutionScope: executionScopeSchema,
+    comparisonExecutionScope: executionScopeSchema.optional(),
+});
+export const listTruecoverageChildEventTreeInput = z.object({
+    eventTitle: z.string().min(1),
+    baseScope: executionScopeSchema,
+    coverageScope: executionScopeSchema.optional(),
+});
+export const getTruecoverageEventTransitionInput = z.object({
+    eventTitle: z.string().min(1),
+    nextEventTitle: z.string().min(1),
+    baseScope: executionScopeSchema,
+    coverageScope: executionScopeSchema.optional(),
+});
+/** EventTimeSeriesMetricType — must match rum_service.proto enum names. */
+export const eventTimeSeriesMetricSchema = z.enum([
+    "EVENT_TIME_SERIES_METRIC_UNSPECIFIED",
+    "SESSION_COUNT",
+    "RELATIVE_FREQUENCY",
+    "PERCENTAGE_TERMINAL_EVENT",
+    "SESSION_POSITION",
+    "TIME_TO_NEXT_EVENT",
+    "REVERSE_INDEX",
+    "TIME_FROM_START",
+    "TIME_TO_END",
+    "TIME_SINCE_PREVIOUS_EVENT",
+]);
+export const getTruecoverageEventTimeSeriesInput = z.object({
+    baseExecutionScope: executionScopeSchema,
+    eventTitle: z.string().optional(),
+    metricType: eventTimeSeriesMetricSchema.optional(),
+});
 export const eventMetadataKeysInput = z.object({
     eventTitle: z.string().min(1),
 });

package/dist/core/tools.js

@@ -11,6 +11,20 @@ function platformToProtoEnum(platform) {
             return "WEB_EXECUTION_PLATFORM";
     }
 }
+/** Build ExecutionScope JSON after Zod parse (platform aliases already normalized). */
+function executionScopeBody(scope) {
+    return {
+        environment: scope.environment,
+        timeWindow: scope.timeWindow,
+        ...(scope.release != null ? { release: scope.release } : {}),
+        ...(scope.branchName != null ? { branchName: scope.branchName } : {}),
+        ...(scope.platform != null ? { platform: scope.platform } : {}),
+        ...(scope.automationEmitsOnly != null ? { automationEmitsOnly: scope.automationEmitsOnly } : {}),
+        ...(scope.metadataFilters != null && scope.metadataFilters.length > 0
+            ? { metadataFilters: scope.metadataFilters }
+            : {}),
+    };
+}
 function listCoverageBody(args) {
     const body = {};
     if (args.release != null)
@@ -111,9 +125,11 @@ export const TOOL_DEFINITIONS = [
     },
     {
         kebab: "create-user-story",
-        description: "Create a user story on the TestChimp project and its plan file stub. " +
-            "Always call this before writing a new story markdown file; use the returned ordinalId as US-<ordinalId> in frontmatter. " +
-            "platformFilePath must be under plans/stories/ and end with .md.",
+        description: "Create a user story on the TestChimp project and allocate a real US-<ordinalId>. " +
+            "Response includes content: canonical stub markdown already containing id: US-<ordinalId>. " +
+            "BLOCKING workflow: call this FIRST → Write the returned content to the repo plans/stories path " +
+            "(edit body as needed but keep id:) → call update-user-story with the full markdown. " +
+            "Never write story markdown that omits id. platformFilePath must be under plans/stories/ and end with .md.",
         inputSchema: S.createUserStoryInput,
         execute: async (args, { postMcp }) => {
             const a = args;
@@ -125,7 +141,12 @@ export const TOOL_DEFINITIONS = [
     },
     {
         kebab: "create-test-scenario",
-        description: "Create a test scenario linked to a user story. platformFilePath must be under plans/scenarios/ and end with .md. " +
+        description: "Create a test scenario linked to a user story and allocate a real TS-<ordinalId>. " +
+            "Response includes content: canonical stub markdown already containing id: TS-<ordinalId> and story: US-<n>. " +
+            "BLOCKING workflow: call this FIRST → Write the returned content to the repo plans/scenarios path " +
+            "(edit body as needed but keep id: and story:) → call update-test-scenario with the full markdown. " +
+            "Never write scenario markdown that omits id. update-test-scenario rejects missing id/story with a clear error. " +
+            "platformFilePath must be under plans/scenarios/ and end with .md. " +
             "userStoryOrdinalId is the numeric part of the parent US-<n> id.",
         inputSchema: S.createTestScenarioInput,
         execute: async (args, { postMcp }) => {
@@ -140,8 +161,8 @@ export const TOOL_DEFINITIONS = [
     {
         kebab: "update-user-story",
         description: "Sync a user story markdown file to the platform after local edits. " +
-            "Parses frontmatter (id: US-..., title, priority) and updates the linked support file and entity. " +
-            "Implementation status is not stored in markdown; use mark-plan-items-implementation-done.",
+            "Requires frontmatter id: US-<n> (platform-issued). Missing id returns an error telling you to call create-user-story first. " +
+            "Parses frontmatter (id, title, priority) and updates the linked support file and entity.",
         inputSchema: S.updatePlanMarkdownInput,
         execute: async (args, { postMcp }) => {
             const a = args;
@@ -151,8 +172,8 @@ export const TOOL_DEFINITIONS = [
     {
         kebab: "update-test-scenario",
         description: "Sync a test scenario markdown file to the platform after local edits. " +
-            "Parses frontmatter (id: TS-..., story: US-..., title, priority) and updates linking if story changes. " +
-            "Implementation status is not stored in markdown; use mark-plan-items-implementation-done.",
+            "Requires frontmatter id: TS-<n> and story: US-<n>. Missing either returns an error telling you to call create-test-scenario first. " +
+            "Parses frontmatter and updates linking if story changes.",
         inputSchema: S.updatePlanMarkdownInput,
         execute: async (args, { postMcp }) => {
             const a = args;
@@ -317,56 +338,115 @@ export const TOOL_DEFINITIONS = [
     },
     {
         kebab: "list-rum-environments",
-        description: "List distinct RUM environment tags for TrueCoverage scoping.",
+        description: "List distinct RUM environment tags for this project. Call this first to choose environment values " +
+            "for TrueCoverage ExecutionScope.environment (e.g. QA, production).",
         inputSchema: S.emptyInput,
         execute: async (_args, { postMcp }) => postMcp("/api/mcp/list_rum_environments", {}),
     },
     {
         kebab: "get-truecoverage-events",
-        description: "TrueCoverage event funnel summaries (ListEventsRequest JSON: baseExecutionScope, comparisonExecutionScope). " +
-            "Optional ExecutionScope.platform: WEB_EXECUTION_PLATFORM | IOS_EXECUTION_PLATFORM | ANDROID_EXECUTION_PLATFORM " +
-            "(filters RUM rows stamped via testchimp-rum-platform header: web=1, ios=2, android=3). " +
-            "Use automationEmitsOnly on comparisonExecutionScope for test-tagged emits only.",
-        inputSchema: S.truecoverageJsonInput,
-        execute: async (args, { postMcp }) => postMcp("/api/mcp/truecoverage_list_events", args ?? {}),
+        description: "TrueCoverage event funnel summaries (ListEventsRequest). " +
+            "baseExecutionScope is the real-user / primary environment; optional comparisonExecutionScope for coverage " +
+            "(set automationEmitsOnly:true on comparison for test-tagged emits only). " +
+            "Each scope needs environment + timeWindow: { relativeWindow: \"604800s\" } or { fixedWindow: { startTime, endTime } } (RFC 3339). " +
+            "Optional platform: web|ios|android or WEB_/IOS_/ANDROID_EXECUTION_PLATFORM. " +
+            "Prefer list-rum-environments first.",
+        inputSchema: S.listTruecoverageEventsInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const body = {
+                baseExecutionScope: executionScopeBody(a.baseExecutionScope),
+            };
+            if (a.comparisonExecutionScope != null) {
+                body.comparisonExecutionScope = executionScopeBody(a.comparisonExecutionScope);
+            }
+            return postMcp("/api/mcp/truecoverage_list_events", body);
+        },
     },
     {
         kebab: "get-truecoverage-event-details",
-        description: "TrueCoverage drill-down for one event title (GetEventDetailsRequest JSON). " +
-            "Optional platform on baseExecutionScope / comparisonExecutionScope (WEB_EXECUTION_PLATFORM, IOS_EXECUTION_PLATFORM, ANDROID_EXECUTION_PLATFORM).",
-        inputSchema: S.truecoverageJsonInput,
-        execute: async (args, { postMcp }) => postMcp("/api/mcp/truecoverage_event_details", args ?? {}),
+        description: "TrueCoverage drill-down for one event (GetEventDetailsRequest). " +
+            "Requires eventTitle plus baseExecutionScope (environment + timeWindow). " +
+            "Optional comparisonExecutionScope for coverage columns (automationEmitsOnly on comparison). " +
+            "Same timeWindow / platform rules as get-truecoverage-events.",
+        inputSchema: S.getTruecoverageEventDetailsInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const body = {
+                eventTitle: a.eventTitle,
+                baseExecutionScope: executionScopeBody(a.baseExecutionScope),
+            };
+            if (a.comparisonExecutionScope != null) {
+                body.comparisonExecutionScope = executionScopeBody(a.comparisonExecutionScope);
+            }
+            return postMcp("/api/mcp/truecoverage_event_details", body);
+        },
     },
     {
         kebab: "get-truecoverage-child-event-tree",
-        description: "TrueCoverage next-event tree for an event (ListChildEventTreeRequest JSON). " +
-            "Optional platform on baseScope / coverageScope (inside each ExecutionScope).",
-        inputSchema: S.truecoverageJsonInput,
-        execute: async (args, { postMcp }) => postMcp("/api/mcp/truecoverage_list_child_event_tree", args ?? {}),
+        description: "TrueCoverage next-event tree after an event (ListChildEventTreeRequest). " +
+            "Requires eventTitle, baseScope (environment + timeWindow); optional coverageScope for PRESENT/ABSENT. " +
+            "Note: metadataFilters on scopes are ignored for transition stats. Field names are baseScope/coverageScope " +
+            "(not baseExecutionScope).",
+        inputSchema: S.listTruecoverageChildEventTreeInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const body = {
+                eventTitle: a.eventTitle,
+                baseScope: executionScopeBody(a.baseScope),
+            };
+            if (a.coverageScope != null)
+                body.coverageScope = executionScopeBody(a.coverageScope);
+            return postMcp("/api/mcp/truecoverage_list_child_event_tree", body);
+        },
     },
     {
         kebab: "get-truecoverage-event-transition",
-        description: "TrueCoverage detailed transition summary between events (GetDetailedEventTransitionSummaryRequest JSON). " +
-            "Optional platform on baseScope / coverageScope (inside each ExecutionScope).",
-        inputSchema: S.truecoverageJsonInput,
-        execute: async (args, { postMcp }) => postMcp("/api/mcp/truecoverage_detailed_event_transition", args ?? {}),
+        description: "TrueCoverage detailed transition stats between two events (GetDetailedEventTransitionSummaryRequest). " +
+            "Requires eventTitle, nextEventTitle, baseScope (environment + timeWindow); optional coverageScope. " +
+            "metadataFilters on scopes are ignored. Uses baseScope/coverageScope field names.",
+        inputSchema: S.getTruecoverageEventTransitionInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const body = {
+                eventTitle: a.eventTitle,
+                nextEventTitle: a.nextEventTitle,
+                baseScope: executionScopeBody(a.baseScope),
+            };
+            if (a.coverageScope != null)
+                body.coverageScope = executionScopeBody(a.coverageScope);
+            return postMcp("/api/mcp/truecoverage_detailed_event_transition", body);
+        },
     },
     {
         kebab: "get-truecoverage-event-time-series",
-        description: "TrueCoverage time series for sessions or metrics (EventTimeSeriesRequest JSON). " +
-            "Optional platform on baseExecutionScope.",
-        inputSchema: S.truecoverageJsonInput,
-        execute: async (args, { postMcp }) => postMcp("/api/mcp/truecoverage_event_time_series", args ?? {}),
+        description: "TrueCoverage daily time series for one metric (EventTimeSeriesRequest). " +
+            "Requires baseExecutionScope (environment + timeWindow). Optional eventTitle and metricType: " +
+            "SESSION_COUNT | RELATIVE_FREQUENCY | PERCENTAGE_TERMINAL_EVENT | SESSION_POSITION | " +
+            "TIME_TO_NEXT_EVENT | REVERSE_INDEX | TIME_FROM_START | TIME_TO_END | TIME_SINCE_PREVIOUS_EVENT.",
+        inputSchema: S.getTruecoverageEventTimeSeriesInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const body = {
+                baseExecutionScope: executionScopeBody(a.baseExecutionScope),
+            };
+            if (a.eventTitle != null)
+                body.eventTitle = a.eventTitle;
+            if (a.metricType != null)
+                body.metricType = a.metricType;
+            return postMcp("/api/mcp/truecoverage_event_time_series", body);
+        },
     },
     {
         kebab: "get-truecoverage-session-metadata-keys",
-        description: "List session-level metadata keys observed for TrueCoverage.",
+        description: "List session-level metadata keys observed in RUM for TrueCoverage filters.",
         inputSchema: S.emptyInput,
         execute: async (_args, { postMcp }) => postMcp("/api/mcp/truecoverage_session_metadata_keys", {}),
     },
     {
         kebab: "get-truecoverage-event-metadata-keys",
-        description: "List metadata keys for a given event title.",
+        description: "List metadata keys for a given event title (ListEventMetadataKeysRequest). " +
+            "Pass eventTitle (CLI: --event-title or json-input).",
         inputSchema: S.eventMetadataKeysInput,
         execute: async (args, { postMcp }) => {
             const a = args;

package/dist/core/version.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_VERSION: string;

package/dist/core/version.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json");
+export const PACKAGE_VERSION = pkg.version;

package/dist/mcp/server.js

@@ -2,7 +2,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { postMcp } from "../core/client.js";
 import { TOOL_DEFINITIONS, runTool } from "../core/tools.js";
-const PACKAGE_VERSION = "0.1.7";
+import { PACKAGE_VERSION } from "../core/version.js";
 function textResult(json) {
     return {
         content: [{ type: "text", text: json }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testchimp/cli",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",