qyl-mcp-server 7.1.1 → 7.2.0

package/dist/mcp-home.html

@@ -6,7 +6,7 @@
   <meta name="color-scheme" content="dark">
   <meta name="description" content="Bring qyl traces, logs, and MCP telemetry into your coding agent.">
   <title>qyl · MCP telemetry for coding agents</title>
-  <script type="module" crossorigin>(function(){let e=document.createElement(`link`).relList;if(e&&e.supports&&e.supports(`modulepreload`))return;for(let e of document.querySelectorAll(`link[rel="modulepreload"]`))n(e);new MutationObserver(e=>{for(let t of e)if(t.type===`childList`)for(let e of t.addedNodes)e.tagName===`LINK`&&e.rel===`modulepreload`&&n(e)}).observe(document,{childList:!0,subtree:!0});function t(e){let t={};return e.integrity&&(t.integrity=e.integrity),e.referrerPolicy&&(t.referrerPolicy=e.referrerPolicy),t.credentials=e.crossOrigin===`use-credentials`?`include`:e.crossOrigin===`anonymous`?`omit`:`same-origin`,t}function n(e){if(e.ep)return;e.ep=!0;let n=t(e);fetch(e.href,n)}})();var e=`7.1.1`,t=`https://mcp.qyl.at/mcp`,n={codex:{title:`terminal`,value:`codex mcp add qyl --url ${t}`},claude:{title:`terminal`,value:`claude mcp add --transport http qyl ${t}`},cursor:{title:`mcp.json`,value:`{
+  <script type="module" crossorigin>(function(){let e=document.createElement(`link`).relList;if(e&&e.supports&&e.supports(`modulepreload`))return;for(let e of document.querySelectorAll(`link[rel="modulepreload"]`))n(e);new MutationObserver(e=>{for(let t of e)if(t.type===`childList`)for(let e of t.addedNodes)e.tagName===`LINK`&&e.rel===`modulepreload`&&n(e)}).observe(document,{childList:!0,subtree:!0});function t(e){let t={};return e.integrity&&(t.integrity=e.integrity),e.referrerPolicy&&(t.referrerPolicy=e.referrerPolicy),t.credentials=e.crossOrigin===`use-credentials`?`include`:e.crossOrigin===`anonymous`?`omit`:`same-origin`,t}function n(e){if(e.ep)return;e.ep=!0;let n=t(e);fetch(e.href,n)}})();var e=`7.2.0`,t=`https://mcp.qyl.at/mcp`,n={codex:{title:`terminal`,value:`codex mcp add qyl --url ${t}`},claude:{title:`terminal`,value:`claude mcp add --transport http qyl ${t}`},cursor:{title:`mcp.json`,value:`{
   "mcpServers": {
     "qyl": {
       "url": "${t}"
@@ -117,12 +117,12 @@
       <p class="section-index">02 / REQUEST SCOPE</p>
       <div class="protocol-heading">
         <h2 id="scope-title">Every call runs inside its request.</h2>
-        <p>One frame around all eleven tools. A tool registered outside it fails the build, so none of the three can go missing.</p>
+        <p>One frame around all eleven tools. A tool registered outside it fails the build, so cancellation and requested progress stay in the common frame.</p>
       </div>
       <div class="protocol-grid scope-grid">
         <article><span>Cancel</span><h3>Stop means stop</h3><p>A <code>notifications/cancelled</code>, or a dropped connection, aborts the in-flight collector fetch at once instead of waiting out its timeout.</p></article>
         <article><span>Progress</span><h3>Only when you ask</h3><p>A request that carries a <code>progressToken</code> gets one <code>notifications/progress</code> per collector round trip and a final <em>Result ready</em>. No token, no noise.</p></article>
-        <article><span>Log</span><h3>One line per call</h3><p>A request that names a log level in its <code>_meta</code> envelope receives one <code>notifications/message</code>: <em>info</em> on success, <em>warning</em> on failure, logger <code>qyl.mcp</code>.</p></article>
+        <article><span>Observe</span><h3>Operation telemetry</h3><p>Native tool telemetry records timing, status and error type through OpenTelemetry. The server sends no deprecated protocol log messages.</p></article>
       </div>
     </section>
 

package/dist/metrics-tools.js

@@ -34,13 +34,13 @@ export function registerMetricsTools(server) {
         title: "List Metrics",
         description: "List the metric instruments recorded for this project: name, kind " +
             "(gauge/sum/histogram), unit, how many attribute streams exist under each " +
-            "name, and when it was last written. Start here — query_metric needs an " +
-            "exact instrument name, and this is where the names come from.",
+            "name, and when it was last written. Useful when the user wants to discover " +
+            "instrument names before querying a metric by its exact name.",
         inputSchema: operationInputSchema(METRICS_PATH),
         outputSchema: compactOutputSchema(MetricsListResponseSchema),
         annotations: READ_ONLY_TELEMETRY_TOOL_ANNOTATIONS,
         _meta: TELEMETRY_TOOL_AUTH_META,
-    }, (args, ctx) => runTool(ctx, "list_metrics", 1, async (scope) => {
+    }, (args, ctx) => runTool(ctx, 1, async (scope) => {
         const { metrics, mode } = await listMetrics(args, scope.collector);
         await scope.step(`Fetched ${metrics.length} metric instrument(s)`);
         return telemetryToolResult(summarizeMetricCatalog(metrics, mode), {
@@ -51,15 +51,14 @@ export function registerMetricsTools(server) {
     server.registerTool("get_metric_series", {
         title: "Get Metric Series",
         description: "List the distinct attribute streams recorded under one metric name, with " +
-            "each stream's attributes, service, and first/last seen. Use it to discover " +
-            "which attribute keys are worth passing to query_metric as group_by or attr " +
-            "filters, before running a range query that would otherwise collapse or " +
-            "explode the result.",
+            "each stream's attributes, service, and first/last seen. Useful when the user " +
+            "wants to discover group_by keys or attr filters for query_metric before " +
+            "choosing the groups in a range query.",
         inputSchema: operationInputSchema(SERIES_PATH),
         outputSchema: compactOutputSchema(MetricSeriesListResponseSchema),
         annotations: READ_ONLY_TELEMETRY_TOOL_ANNOTATIONS,
         _meta: TELEMETRY_TOOL_AUTH_META,
-    }, (args, ctx) => runTool(ctx, "get_metric_series", 1, async (scope) => {
+    }, (args, ctx) => runTool(ctx, 1, async (scope) => {
         const { series, mode } = await listMetricSeries(args, scope.collector);
         await scope.step(`Fetched ${series.length} series of ${args.metric_name}`);
         return telemetryToolResult(summarizeMetricSeries(series, mode), {
@@ -69,17 +68,18 @@ export function registerMetricsTools(server) {
     }));
     server.registerTool("query_metric", {
         title: "Query Metric",
-        description: "Run a time-bucketed range query over one metric: a window (start_time, " +
+        description: "Run a time-bucketed range query when the user wants to compare a metric " +
+            "over time or across groups: a window (start_time, " +
             "end_time), a bucket width (step_ms), a reducer (aggregation: avg, min, max, " +
             "sum, count, last, p50, p90, p95, p99), optional group_by attribute keys, and " +
             "optional attr/attr_prefix matchers written 'key=value'. Returns one stream " +
-            "per grouping with its buckets. One bucket spanning the whole window collapses " +
-            "the answer to a single number.",
+            "per grouping with its buckets. With step_ms equal to the window duration, " +
+            "each grouping yields one bucket: one number per series.",
         inputSchema: operationInputSchema(QUERY_PATH),
         outputSchema: compactOutputSchema(MetricQueryResultSchema),
         annotations: READ_ONLY_TELEMETRY_TOOL_ANNOTATIONS,
         _meta: TELEMETRY_TOOL_AUTH_META,
-    }, (args, ctx) => runTool(ctx, "query_metric", 1, async (scope) => {
+    }, (args, ctx) => runTool(ctx, 1, async (scope) => {
         const { result, mode } = await queryMetric(args, scope.collector);
         await scope.step(`Queried ${args.metric_name}: ${result.series.length} series, ` +
             `${result.series[0]?.buckets.length ?? 0} bucket(s) each`);

package/dist/metrics-tools.js.map

@@ -1 +1 @@
-{"version":3,"file":"metrics-tools.js","sourceRoot":"","sources":["../src/metrics-tools.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"metrics-tools.js","sourceRoot":"","sources":["../src/metrics-tools.ts"],"names":[],"mappings":"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"}

package/dist/native-execution.d.ts

@@ -1,12 +1,11 @@
-import type { WorkbenchExecutionCost, WorkbenchExecutionTokenUsage } from "@ancplua/qyl-api-schema/types";
 import type { McpServer, CallToolRequest, CallToolResult, ServerContext } from "@modelcontextprotocol/server";
-import { z } from "zod";
+import * as z from "zod/v4";
 import type { McpTelemetryTransport } from "./mcp-semconv.js";
 import { SecretRedactor } from "./secret-redactor.js";
 import { McpTelemetry } from "./telemetry.js";
 declare const NativeExecutionRecordSchema: z.ZodObject<{
     id: z.ZodString;
-    serverId: z.ZodLiteral<"qyl.mcp/native">;
+    toolName: z.ZodString;
     status: z.ZodEnum<{
         failed: "failed";
         running: "running";
@@ -16,51 +15,7 @@ declare const NativeExecutionRecordSchema: z.ZodObject<{
     startedAt: z.ZodISODateTime;
     completedAt: z.ZodOptional<z.ZodISODateTime>;
     durationMs: z.ZodOptional<z.ZodNumber>;
-    attemptCount: z.ZodLiteral<1>;
-    request: z.ZodObject<{
-        requestId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-        toolName: z.ZodString;
-        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        transport: z.ZodEnum<{
-            builtin: "builtin";
-            http: "http";
-            inproc: "inproc";
-            sse: "sse";
-            stdio: "stdio";
-            "streamable-http": "streamable-http";
-            streamable_http: "streamable_http";
-        }>;
-        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strict>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodObject<{
-        code: z.ZodString;
-        message: z.ZodString;
-    }, z.core.$strict>>;
-    tokenUsage: z.ZodOptional<z.ZodType<WorkbenchExecutionTokenUsage, unknown, z.core.$ZodTypeInternals<WorkbenchExecutionTokenUsage, unknown>>>;
-    cost: z.ZodOptional<z.ZodType<WorkbenchExecutionCost, unknown, z.core.$ZodTypeInternals<WorkbenchExecutionCost, unknown>>>;
-    protocolEvents: z.ZodArray<z.ZodObject<{
-        sequence: z.ZodNumber;
-        timestamp: z.ZodISODateTime;
-        direction: z.ZodEnum<{
-            inbound: "inbound";
-            outbound: "outbound";
-        }>;
-        messageKind: z.ZodEnum<{
-            error: "error";
-            request: "request";
-            result: "result";
-        }>;
-        jsonrpc: z.ZodLiteral<"2.0">;
-        requestId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-        method: z.ZodLiteral<"tools/call">;
-        payload: z.ZodUnknown;
-    }, z.core.$strict>>;
-    telemetryCorrelation: z.ZodObject<{
-        executionId: z.ZodString;
-        traceIds: z.ZodArray<z.ZodString>;
-        spanIds: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
+    errorType: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type NativeExecutionRecord = z.infer<typeof NativeExecutionRecordSchema>;
 export interface NativeExecutionRepository {
@@ -73,7 +28,7 @@ export interface FileNativeExecutionRepositoryOptions {
     redactor?: SecretRedactor;
     environment?: Readonly<Record<string, string | undefined>>;
 }
-/** Durable, redacted native-server evidence kept separately from workbench state. */
+/** Bounded operation metadata kept separately from Workbench execution state. */
 export declare class FileNativeExecutionRepository implements NativeExecutionRepository {
     private store;
     private readonly openStore;
@@ -81,17 +36,18 @@ export declare class FileNativeExecutionRepository implements NativeExecutionRep
     private readonly maxExecutions;
     private readonly now;
     private initialization;
+    private needsMigration;
     constructor(options?: FileNativeExecutionRepositoryOptions);
     /**
      * Move a state file this build cannot read out of the way, and say so.
      *
-     * The schema deliberately refuses to half-parse an older layout, but refusing
+     * The schema deliberately refuses to guess an unknown layout, but refusing
      * forever is not the same as refusing to guess: a state file written before a
      * version bump would otherwise fail every single tool call for the life of the
      * installation, because the store caches its failed load and evidence is
      * written before the tool runs. Renaming preserves the old records for anyone
-     * who wants them and lets this process start a fresh log. Nothing is deleted
-     * and nothing is migrated.
+     * who wants them and lets this process start a fresh log. Known version-1/2
+     * files follow the payload-removing migration instead of this recovery path.
      */
     private archiveUnreadableState;
     save(record: NativeExecutionRecord): Promise<void>;

package/dist/native-execution.js

@@ -1,84 +1,46 @@
 import { CallToolRequestSchema, CallToolResultSchema } from "@modelcontextprotocol/core";
-import { ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/server";
+import { ProtocolError } from "@modelcontextprotocol/server";
 import { randomUUID } from "node:crypto";
 import { rename } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { z } from "zod";
+import * as z from "zod/v4";
 import { AtomicJsonStore, PersistenceError } from "./atomic-json-store.js";
-import { WorkbenchExecutionCostSchema, WorkbenchExecutionTokenUsageSchema, } from "./contract-validation.js";
-import { extractExecutionEvidence } from "./execution-evidence.js";
-import { MAX_PERSISTED_RESULT_CHARACTERS, sanitizePersistedToolResult, } from "./execution-result.js";
 import { SecretRedactor } from "./secret-redactor.js";
 import { McpTelemetry, } from "./telemetry.js";
-// 2: usage and cost evidence follows the published contract's snake_case names,
-// so a version-1 file must never half-parse. It is set aside rather than read —
-// see archiveUnreadableState.
-const NATIVE_STATE_VERSION = 2;
+// 3: operation metadata only. Known older layouts are projected into this
+// schema and replaced atomically, without keeping an archive of their payloads.
+const NATIVE_STATE_VERSION = 3;
 const DEFAULT_MAX_EXECUTIONS = 1_000;
 const NATIVE_SERVER_ID = "qyl.mcp/native";
-const MAX_PROTOCOL_PAYLOAD_CHARACTERS = 64_000;
 const IdentifierSchema = z.string().min(1).max(256);
 const IsoDateSchema = z.iso.datetime({ offset: true });
-const JsonRpcRequestIdSchema = z.union([z.string().max(2_048), z.number().finite()]);
-// Usage and cost evidence is the published contract's own shape, so the
-// persisted record validates against the generated schema rather than a local
-// copy that can drift from it.
-const TokenUsageSchema = WorkbenchExecutionTokenUsageSchema;
-const CostSchema = WorkbenchExecutionCostSchema;
-const ProtocolEventSchema = z.object({
-    sequence: z.number().int().positive(),
-    timestamp: IsoDateSchema,
-    direction: z.enum(["inbound", "outbound"]),
-    messageKind: z.enum(["request", "result", "error"]),
-    jsonrpc: z.literal("2.0"),
-    requestId: JsonRpcRequestIdSchema,
-    method: z.literal("tools/call"),
-    payload: z.unknown(),
-}).strict();
 const NativeExecutionRecordSchema = z.object({
+    // Generated by this server; never a client-provided JSON-RPC request id.
     id: IdentifierSchema,
-    serverId: z.literal(NATIVE_SERVER_ID),
+    toolName: z.string().min(1).max(1_024),
     status: z.enum(["running", "succeeded", "failed"]),
     createdAt: IsoDateSchema,
     startedAt: IsoDateSchema,
     completedAt: IsoDateSchema.optional(),
     durationMs: z.number().finite().nonnegative().optional(),
-    attemptCount: z.literal(1),
-    request: z.object({
-        requestId: JsonRpcRequestIdSchema,
-        toolName: z.string().min(1).max(1_024),
-        arguments: z.record(z.string(), z.unknown()),
-        transport: z.enum([
-            "stdio",
-            "http",
-            "streamable_http",
-            "streamable-http",
-            "sse",
-            "inproc",
-            "builtin",
-        ]),
-        meta: z.record(z.string(), z.unknown()).optional(),
-    }).strict(),
-    result: z.unknown().optional(),
-    error: z.object({
-        code: z.string().min(1).max(128),
-        message: z.string().min(1).max(4_096),
-    }).strict().optional(),
-    tokenUsage: TokenUsageSchema.optional(),
-    cost: CostSchema.optional(),
-    protocolEvents: z.array(ProtocolEventSchema).min(1).max(2),
-    telemetryCorrelation: z.object({
-        executionId: IdentifierSchema,
-        traceIds: z.array(z.string().regex(/^[0-9a-f]{32}$/u)).max(2),
-        spanIds: z.array(z.string().regex(/^[0-9a-f]{16}$/u)).max(2),
-    }).strict(),
+    errorType: z.string().min(1).max(128).optional(),
 }).strict();
 const NativeExecutionStateSchema = z.object({
     version: z.literal(NATIVE_STATE_VERSION),
     executions: z.array(NativeExecutionRecordSchema),
 }).strict();
-/** Durable, redacted native-server evidence kept separately from workbench state. */
+// Strip unknown fields before migration: legacy request/result contents must
+// never reach a new write, even when an old file contains unrecognized fields.
+const LegacyNativeExecutionStateSchema = z.object({
+    version: z.union([z.literal(1), z.literal(2)]),
+    executions: z.array(NativeExecutionRecordSchema.omit({ toolName: true, errorType: true })
+        .extend({
+        request: z.object({ toolName: NativeExecutionRecordSchema.shape.toolName }),
+        error: z.object({ code: NativeExecutionRecordSchema.shape.errorType }).optional(),
+    }).strip()),
+}).strict();
+/** Bounded operation metadata kept separately from Workbench execution state. */
 export class FileNativeExecutionRepository {
     store;
     openStore;
@@ -86,18 +48,31 @@ export class FileNativeExecutionRepository {
     maxExecutions;
     now;
     initialization;
+    needsMigration = false;
     constructor(options = {}) {
         const environment = options.environment ?? process.env;
         const redactor = options.redactor ?? new SecretRedactor({
             environment,
-            maxStringLength: MAX_PERSISTED_RESULT_CHARACTERS + 1,
         });
         this.maxExecutions = positiveInteger(options.maxExecutions ?? DEFAULT_MAX_EXECUTIONS, "maxExecutions");
         this.now = options.now ?? Date.now;
         this.filePath = options.filePath ?? nativeStatePath(environment);
         this.openStore = () => new AtomicJsonStore(this.filePath, {
             initial: () => ({ version: NATIVE_STATE_VERSION, executions: [] }),
-            parse: (value) => NativeExecutionStateSchema.parse(value),
+            parse: (value) => {
+                const legacy = LegacyNativeExecutionStateSchema.safeParse(value);
+                if (!legacy.success)
+                    return NativeExecutionStateSchema.parse(value);
+                this.needsMigration = true;
+                return NativeExecutionStateSchema.parse({
+                    version: NATIVE_STATE_VERSION,
+                    executions: legacy.data.executions.map(({ request, error, ...record }) => ({
+                        ...record,
+                        toolName: request.toolName,
+                        ...(error?.code === undefined ? {} : { errorType: error.code }),
+                    })),
+                });
+            },
             prepareForWrite: (value) => NativeExecutionStateSchema.parse(redactor.redact(value)),
         });
         this.store = this.openStore();
@@ -105,13 +80,13 @@ export class FileNativeExecutionRepository {
     /**
      * Move a state file this build cannot read out of the way, and say so.
      *
-     * The schema deliberately refuses to half-parse an older layout, but refusing
+     * The schema deliberately refuses to guess an unknown layout, but refusing
      * forever is not the same as refusing to guess: a state file written before a
      * version bump would otherwise fail every single tool call for the life of the
      * installation, because the store caches its failed load and evidence is
      * written before the tool runs. Renaming preserves the old records for anyone
-     * who wants them and lets this process start a fresh log. Nothing is deleted
-     * and nothing is migrated.
+     * who wants them and lets this process start a fresh log. Known version-1/2
+     * files follow the payload-removing migration instead of this recovery path.
      */
     async archiveUnreadableState(reason) {
         const archived = `${this.filePath}.unreadable-${new Date(this.now()).toISOString().replaceAll(":", "-")}`;
@@ -155,6 +130,10 @@ export class FileNativeExecutionRepository {
             this.store = this.openStore();
             await this.store.initialize();
         }
+        if (this.needsMigration) {
+            await this.store.replace(await this.store.read());
+            this.needsMigration = false;
+        }
         const completedMs = this.now();
         const completedAt = timestamp(completedMs);
         const current = await this.store.read();
@@ -167,10 +146,7 @@ export class FileNativeExecutionRepository {
                 record.status = "failed";
                 record.completedAt = completedAt;
                 record.durationMs = Math.max(0, completedMs - Date.parse(record.startedAt));
-                record.error = {
-                    code: "process_interrupted",
-                    message: "The qyl.mcp process stopped before this native tool call completed.",
-                };
+                record.errorType = "process_interrupted";
             }
         });
     }
@@ -187,7 +163,6 @@ export class NativeExecutionRuntime {
         this.telemetry = options.telemetry;
         this.redactor = options.redactor ?? new SecretRedactor({
             environment: process.env,
-            maxStringLength: MAX_PERSISTED_RESULT_CHARACTERS + 1,
         });
         this.now = options.now ?? Date.now;
         this.id = options.id ?? randomUUID;
@@ -196,28 +171,14 @@ export class NativeExecutionRuntime {
         const startedMs = this.now();
         const executionId = this.id();
         const startedAt = timestamp(startedMs);
-        const requestId = input.ctx.mcpReq.id;
-        const durableRequestId = sanitizeRequestId(requestId, this.redactor);
         const toolName = input.request.params.name;
         const operation = this.startTelemetry(input, executionId, startedMs);
         const running = NativeExecutionRecordSchema.parse({
             id: executionId,
-            serverId: NATIVE_SERVER_ID,
+            toolName: this.redactor.redactText(toolName).slice(0, 1_024),
             status: "running",
             createdAt: startedAt,
             startedAt,
-            attemptCount: 1,
-            request: {
-                requestId: durableRequestId,
-                toolName: this.redactor.redactText(toolName).slice(0, 1_024),
-                arguments: sanitizeArguments(input.request.params.arguments, this.redactor),
-                transport: input.transport,
-                ...(input.request.params._meta === undefined
-                    ? {}
-                    : { meta: sanitizeRecord(input.request.params._meta, this.redactor) }),
-            },
-            protocolEvents: [requestEvent(input, durableRequestId, startedAt, this.redactor)],
-            telemetryCorrelation: correlation(executionId, operation?.correlation),
         });
         try {
             await this.repository.save(running);
@@ -225,7 +186,6 @@ export class NativeExecutionRuntime {
         catch (error) {
             operation?.end({
                 endTimeMs: this.now(),
-                jsonRpcRequestId: requestId,
                 errorType: "evidence_persistence_failed",
             });
             throw new EvidenceRecordingError(error);
@@ -243,12 +203,7 @@ export class NativeExecutionRuntime {
                 status: "failed",
                 completedAt,
                 durationMs: duration(startedMs, completedMs),
-                error: errorEvidence(error, this.redactor),
-                protocolEvents: [
-                    ...running.protocolEvents,
-                    errorEvent(durableRequestId, toolName, completedAt, error, this.redactor),
-                ],
-                telemetryCorrelation: correlation(executionId, operation?.correlation),
+                errorType: errorType(error),
             });
             try {
                 await this.repository.save(failedRecord);
@@ -256,14 +211,12 @@ export class NativeExecutionRuntime {
             catch (persistenceError) {
                 operation?.end({
                     endTimeMs: this.now(),
-                    jsonRpcRequestId: requestId,
                     errorType: "evidence_persistence_failed",
                 });
                 throw new EvidenceRecordingError(persistenceError);
             }
             operation?.end({
                 endTimeMs: completedMs,
-                jsonRpcRequestId: requestId,
                 errorType: errorType(error),
                 ...(error instanceof ProtocolError
                     ? { rpcResponseStatusCode: String(error.code) }
@@ -273,29 +226,13 @@ export class NativeExecutionRuntime {
         }
         const completedMs = this.now();
         const completedAt = timestamp(completedMs);
-        const durableResult = sanitizePersistedToolResult(result, this.redactor);
-        const evidence = extractExecutionEvidence(result);
         const toolFailed = result.isError === true;
         const completedRecord = NativeExecutionRecordSchema.parse({
             ...running,
             status: toolFailed ? "failed" : "succeeded",
             completedAt,
             durationMs: duration(startedMs, completedMs),
-            result: durableResult,
-            ...(toolFailed
-                ? {
-                    error: {
-                        code: "tool_result_error",
-                        message: "The MCP tool returned an error result.",
-                    },
-                }
-                : {}),
-            ...evidenceFields(evidence, this.redactor),
-            protocolEvents: [
-                ...running.protocolEvents,
-                resultEvent(durableRequestId, completedAt, durableResult),
-            ],
-            telemetryCorrelation: correlation(executionId, operation?.correlation),
+            ...(toolFailed ? { errorType: "tool_result_error" } : {}),
         });
         try {
             await this.repository.save(completedRecord);
@@ -303,16 +240,13 @@ export class NativeExecutionRuntime {
         catch (error) {
             operation?.end({
                 endTimeMs: this.now(),
-                jsonRpcRequestId: requestId,
                 errorType: "evidence_persistence_failed",
             });
             throw new EvidenceRecordingError(error);
         }
         operation?.end({
             endTimeMs: completedMs,
-            jsonRpcRequestId: requestId,
             ...(toolFailed ? { errorType: "tool_error" } : {}),
-            responseBody: this.redactor.redact(result),
         });
         return result;
     }
@@ -332,7 +266,6 @@ export class NativeExecutionRuntime {
                 transport: input.transport,
                 jsonRpcProtocolVersion: "2.0",
                 executionId,
-                requestBody: this.redactor.redact(input.request),
                 remotePropagation: propagationCarrier(input.request.params._meta),
                 startTimeMs: startedMs,
             });
@@ -444,7 +377,6 @@ export async function closeDefaultNativeExecutionRuntime() {
 function createDefaultRuntime(environment) {
     const redactor = new SecretRedactor({
         environment,
-        maxStringLength: MAX_PERSISTED_RESULT_CHARACTERS + 1,
     });
     const repository = new FileNativeExecutionRepository({ environment, redactor });
     let telemetry;
@@ -460,63 +392,6 @@ function nativeStatePath(environment) {
     return environment.QYL_MCP_NATIVE_STATE_PATH
         ?? join(homedir(), ".qyl", "mcp-native-executions.json");
 }
-function requestEvent(input, requestId, at, redactor) {
-    return {
-        sequence: 1,
-        timestamp: at,
-        direction: "inbound",
-        messageKind: "request",
-        jsonrpc: "2.0",
-        requestId,
-        method: "tools/call",
-        payload: boundPayload(redactor.redact({
-            jsonrpc: "2.0",
-            id: requestId,
-            method: "tools/call",
-            params: input.request.params,
-        })),
-    };
-}
-function resultEvent(requestId, at, result) {
-    return {
-        sequence: 2,
-        timestamp: at,
-        direction: "outbound",
-        messageKind: "result",
-        jsonrpc: "2.0",
-        requestId,
-        method: "tools/call",
-        payload: boundPayload({ jsonrpc: "2.0", id: requestId, result }),
-    };
-}
-function errorEvent(requestId, toolName, at, error, redactor) {
-    const evidence = errorEvidence(error, redactor);
-    return {
-        sequence: 2,
-        timestamp: at,
-        direction: "outbound",
-        messageKind: "error",
-        jsonrpc: "2.0",
-        requestId,
-        method: "tools/call",
-        payload: boundPayload({
-            jsonrpc: "2.0",
-            id: requestId,
-            error: {
-                code: error instanceof ProtocolError ? error.code : ProtocolErrorCode.InternalError,
-                message: evidence.message,
-                data: { toolName: redactor.redactText(toolName).slice(0, 1_024) },
-            },
-        }),
-    };
-}
-function errorEvidence(error, redactor) {
-    const message = redactor.redactText(error instanceof Error ? error.message : String(error));
-    return {
-        code: errorType(error),
-        message: message.trim().length === 0 ? "Native MCP tool execution failed." : message.slice(0, 4_096),
-    };
-}
 function errorType(error) {
     if (error instanceof ProtocolError)
         return `mcp_${error.code}`;
@@ -525,61 +400,15 @@ function errorType(error) {
     }
     return "native_tool_failure";
 }
-function correlation(executionId, span) {
-    return {
-        executionId,
-        traceIds: span === undefined ? [] : [span.traceId],
-        spanIds: span === undefined ? [] : [span.spanId],
-    };
-}
 function propagationCarrier(value) {
     if (!isRecord(value))
         return undefined;
-    const entries = Object.entries(value)
-        .filter((entry) => typeof entry[1] === "string");
-    return entries.length === 0 ? undefined : Object.fromEntries(entries);
-}
-function sanitizeArguments(value, redactor) {
-    return sanitizeRecord(value ?? {}, redactor);
-}
-function sanitizeRecord(value, redactor) {
-    const sanitized = redactor.redact(value);
-    if (!isRecord(sanitized))
-        return {};
-    const bounded = boundPayload(sanitized);
-    return isRecord(bounded) ? bounded : {};
-}
-function boundPayload(value) {
-    const serialized = JSON.stringify(value);
-    if (serialized === undefined || serialized.length <= MAX_PROTOCOL_PAYLOAD_CHARACTERS) {
-        return value;
-    }
-    return {
-        truncated: true,
-        originalCharacters: serialized.length,
-        preview: `${serialized.slice(0, MAX_PROTOCOL_PAYLOAD_CHARACTERS - 1)}…`,
-    };
-}
-function evidenceFields(evidence, redactor) {
-    const source = evidence.cost?.source === undefined
-        ? undefined
-        : redactor.redactText(evidence.cost.source).trim().slice(0, 256);
-    const cost = evidence.cost === undefined
-        ? undefined
-        : {
-            amount_usd: evidence.cost.amount_usd,
-            estimated: evidence.cost.estimated,
-            ...(source === undefined || source.length === 0 ? {} : { source }),
-        };
-    return {
-        ...(evidence.tokenUsage === undefined ? {} : { tokenUsage: evidence.tokenUsage }),
-        ...(cost === undefined ? {} : { cost }),
-    };
-}
-function sanitizeRequestId(value, redactor) {
-    return typeof value === "string"
-        ? redactor.redactText(value).slice(0, 2_048)
-        : value;
+    // Preserve trace parenting without passing arbitrary metadata or baggage to
+    // logging/exporters. OpenTelemetry validates the trace/span IDs on extraction.
+    const traceparent = value.traceparent;
+    return typeof traceparent === "string"
+        ? { traceparent }
+        : undefined;
 }
 function duration(startedMs, completedMs) {
     return Math.max(0, completedMs - startedMs);