@wirecat/cli-core 0.466.0 → 0.467.0

package/dist/mcp/server.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/server";
 import { StdioServerTransport, serveStdio } from "@modelcontextprotocol/server/stdio";
 import { CliError, mcpErrorResult } from "@wirecat/cli-base";
@@ -25,6 +26,7 @@ import { levelFor, readKeysForCommand } from "../sends/permissions.js";
 import { openStore } from "../store/store.js";
 import { runCommandForAgent, toolsFromCommands } from "./agent.js";
 import { agentLog } from "./agent-log.js";
+import { callerOf, withCaller } from "./caller.js";
 import { mcpHttpMarker } from "./http/state.js";
 import { instructions } from "./instructions.js";
 import { registerPrompts } from "./prompts.js";
@@ -195,7 +197,7 @@ export const createServer = (command, context, messenger, sessionOptions) => {
      * One command at a time, on the session's connection, opened only if the command asks for it. A failure that may
      * have been the connection's drops it, as the session does for its own calls.
      */
-    const invoke = (one, input, env) => new Promise((resolve) => {
+    const invoke = (one, input, env, caller) => new Promise((resolve) => {
         let finish;
         let held;
         const connection = () => new Promise((lend, refuse) => {
@@ -219,6 +221,7 @@ export const createServer = (command, context, messenger, sessionOptions) => {
             stdin,
             connection,
             environment: agentEnvironment,
+            caller,
         }).then(async (answer) => {
             finish?.("error" in answer && !harmless(answer.error.error.code));
             await held?.catch(() => undefined);
@@ -226,12 +229,12 @@ export const createServer = (command, context, messenger, sessionOptions) => {
         });
     });
     let queue = Promise.resolve();
-    const queued = (one, input, env) => {
-        const next = queue.then(() => invoke(one, input, env));
+    const queued = (one, input, env, caller) => {
+        const next = queue.then(() => invoke(one, input, env, caller));
         queue = next.catch(() => undefined);
         return next;
     };
-    const asCommand = (one) => ({
+    const asCommand = (one, source) => ({
         title: one.title,
         description: one.description,
         writes: one.writes,
@@ -243,7 +246,9 @@ export const createServer = (command, context, messenger, sessionOptions) => {
             // The caller's trace reaches the run, its send journal lines and its record, as `TRACEPARENT` does.
             const traceparent = ctx?.mcpReq?._meta?.traceparent;
             const env = typeof traceparent === "string" ? { ...context.env, TRACEPARENT: traceparent } : context.env;
-            const answer = await queued(one, args, env);
+            const caller = callerOf(ctx, keyOfCommand(one.command), source);
+            // The connection the session opens for this call is recorded under the same caller.
+            const answer = await withCaller(caller, () => queued(one, args, env, caller));
             const result = "error" in answer
                 ? mcpErrorResult(JSON.parse(agentJson(answer.error)))
                 : (() => {
@@ -266,6 +271,12 @@ export const createServer = (command, context, messenger, sessionOptions) => {
         },
     });
     const build = () => {
+        // Built once for a stdio connection; over HTTP the session or the OAuth client identifies the caller instead.
+        const callers = {
+            env: context.env,
+            client: () => server.server.getClientVersion(),
+            connectionId: randomUUID(),
+        };
         const server = new McpServer({ name: app.command, version: app.version }, {
             instructions: instructions({
                 command: app.command,
@@ -305,11 +316,12 @@ export const createServer = (command, context, messenger, sessionOptions) => {
                 env: context.env,
                 ...(context.keyring ? { keyring: context.keyring } : {}),
                 embedders,
-                history: settings.keepFailedRuns,
+                history: settings.record,
             },
+            callers,
         };
         registerCommands(server, app.command, {
-            ...Object.fromEntries(commands.map((one) => [one.command, asCommand(one)])),
+            ...Object.fromEntries(commands.map((one) => [one.command, asCommand(one, callers)])),
             ...Object.fromEntries(Object.entries(surfaceCommands({ ...pictures, status }, registration)).map(([name, one]) => [
                 name,
                 {

package/dist/mcp/surface.js

@@ -1,8 +1,10 @@
+import { randomUUID } from "node:crypto";
 import { toJsonSchema, toStandardJsonSchema } from "@valibot/to-json-schema";
 import { CliError } from "@wirecat/cli-base";
 import * as v from "valibot";
 import { answerSchema, listOf } from "../cli/envelope.js";
 import { ENTITIES } from "../entities/index.js";
+import { callerOf, currentCaller, withCaller } from "./caller.js";
 import { agentArguments } from "./text.js";
 import { answered, commandOf, entryRunner, failed, inputOf, outputSchemaOf, READ, syncAllowedFor, UNTRUSTED, UNTRUSTED_NEUTRAL, WRITE, } from "./tool.js";
 const MATCHES = 8;
@@ -113,6 +115,12 @@ isMessenger) => {
         });
         return answered(list);
     });
+    // A CLI's own server runs in its own process: its environment names the agent that started it on stdio.
+    const callers = {
+        env: process.env,
+        client: () => server.server.getClientVersion(),
+        connectionId: randomUUID(),
+    };
     const runner = (writing) => async ({ command: asked, arguments: given }, ctx) => {
         try {
             const command = byNormal.get(normal(asked));
@@ -125,14 +133,15 @@ isMessenger) => {
             if (one.writes !== writing)
                 throw new CliError("validation_error", `"${command}" ${writing ? "only reads" : "writes"}: call it with ${prefix}_${writing ? "read" : "write"}`);
             const args = writing ? agentArguments(given ?? {}) : (given ?? {});
+            const caller = currentCaller() ?? callerOf(ctx, command.replace(/[ -]/g, "_"), callers);
             if (one.checked)
-                return runnableOnly(await one.run(args, ctx), (named) => byNormal.has(normal(named)));
+                return runnableOnly(await withCaller(caller, () => one.run(args, ctx)), (named) => byNormal.has(normal(named)));
             const parsed = v.safeParse(v.strictObject(one.input.entries), args);
             if (!parsed.success)
                 throw new CliError("validation_error", `${command}: ${v.summarize(parsed.issues)}`, {
                     arguments: toJsonSchema(one.input),
                 });
-            return runnableOnly(await one.run(parsed.output, ctx), (named) => byNormal.has(normal(named)));
+            return runnableOnly(await withCaller(caller, () => one.run(parsed.output, ctx)), (named) => byNormal.has(normal(named)));
         }
         catch (error) {
             return failed(error, errors);

package/dist/mcp/tool.d.ts

@@ -13,6 +13,7 @@ import type { SendGuard } from "../sends/guard.js";
 import { type PermissionKey } from "../sends/permissions.js";
 import { type Services } from "../services/index.js";
 import type { AccountKey, MessageStore } from "../store/store.js";
+import { type CallerSource } from "./caller.js";
 import type { MessengerSession } from "./session.js";
 export declare const limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 100, undefined>, v.DescriptionAction<number, "how many">]>, undefined>;
 export declare const page: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "which page, from 1">]>, undefined>;
@@ -34,7 +35,7 @@ export interface Defaults {
     limit: number;
     guard: SendGuard;
     /** The profile's own entries, for a tool reading a setting of its own — `transcribeWith`. */
-    settings: Pick<Settings, "configured" | "shared" | "profile"> & Partial<Pick<Settings, "permissions" | "searchCatchUp" | "pictureSearch" | "searchReranker" | "offline">> & AISettings;
+    settings: Pick<Settings, "configured" | "shared" | "profile"> & Partial<Pick<Settings, "permissions" | "searchCatchUp" | "pictureSearch" | "searchReranker" | "offline" | "record" | "keepFailedRuns" | "keepRunsForDays" | "keepSuccessfulRunsForDays" | "runsSizeLimitMb">> & AISettings;
     env: NodeJS.ProcessEnv;
     keyring?: KeyringStore;
     /** The server's open models, kept between `search_conversations` calls. */
@@ -123,6 +124,8 @@ export interface Registration {
     log?: (call: ToolCall) => Promise<void>;
     /** The CLI's commands, by which an answer's next steps are judged safe to run unasked. */
     targets?: NonNullable<StepInput["targets"]>;
+    /** How a call's caller is worked out on this connection (`callerOf`); without it the environment's agent is kept. */
+    callers?: CallerSource;
 }
 export type ToolTier = "read" | "draft" | "write-private" | "write-public" | "destructive" | "admin";
 export interface ToolCall {

package/dist/mcp/tool.js

@@ -9,13 +9,14 @@ import { MAX_BUFFERED_INPUT } from "../cli/input-policy.js";
 import { refuseLacking } from "../cli/messenger/lacks.js";
 import { ENTITIES } from "../entities/index.js";
 import { failureContext } from "../errors/reasons.js";
-import { partialOutcome, startRecording } from "../runs/recording.js";
+import { startRecording } from "../runs/recording.js";
 import { newRunId } from "../runs/run.js";
-import { runContextOf } from "../runs/run-context.js";
+import { keepsSuccess, runContextOf } from "../runs/run-context.js";
 import { inRun } from "../runs/scope.js";
 import { keyForCommand, levelFor, readKeysForCommand } from "../sends/permissions.js";
 import { onlineDeps, storeModeDeps } from "../services/deps.js";
 import { servicesFor } from "../services/index.js";
+import { callerOf, currentCaller, withCaller } from "./caller.js";
 import { agentJson } from "./text.js";
 export const limit = v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(100), v.description("how many")));
 export const page = v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.description("which page, from 1")));
@@ -104,19 +105,25 @@ export const entryRunner = (registration) => {
         const command = `mcp ${commandOf(key, definition)}`;
         const traceId = traceIdOf(ctx?.mcpReq?._meta?.traceparent);
         const app = registration.messenger?.app;
-        const recording = key !== "runs_search" && registration.defaults.history !== false && app?.appName
+        const caller = registration.callers ? callerOf(ctx, key, registration.callers) : currentCaller();
+        const env = registration.defaults.env ?? process.env;
+        const settings = registration.defaults.settings;
+        const recording = key !== "runs_search" && settings.keepFailedRuns !== false && app?.appName
             ? startRecording({
                 app,
                 command,
-                ...(registration.defaults.settings.profile === undefined
-                    ? {}
-                    : { profile: registration.defaults.settings.profile }),
-                env: registration.defaults.env,
-                record: false,
+                ...(settings.profile === undefined ? {} : { profile: settings.profile }),
+                env,
+                record: keepsSuccess({ record: settings.record ?? true, fromFlag: false, env, caller }),
                 keepFailed: true,
                 trace: false,
                 format: "json",
-                context: runContextOf({ bin: app.command, command, env: registration.defaults.env ?? process.env }),
+                context: runContextOf({ bin: app.command, command, env, caller }),
+                ...(settings.keepRunsForDays === undefined ? {} : { keepDays: settings.keepRunsForDays }),
+                ...(settings.keepSuccessfulRunsForDays === undefined
+                    ? {}
+                    : { keepSuccessDays: settings.keepSuccessfulRunsForDays }),
+                ...(settings.runsSizeLimitMb === undefined ? {} : { maxBytes: settings.runsSizeLimitMb * 1024 * 1024 }),
                 ...(traceId === undefined ? {} : { traceId }),
             })
             : undefined;
@@ -127,8 +134,9 @@ export const entryRunner = (registration) => {
             startedAt,
             ...(profile === undefined ? {} : { profile }),
             ...(traceId === undefined ? {} : { traceId }),
+            ...(recording ? { events: recording.events } : {}),
         };
-        const result = await inRun(scope, () => {
+        const work = () => inRun(scope, () => {
             const input = inputOf(definition, syncAllowedFor(key, registration.defaults));
             const parsed = v.safeParse(input, args);
             return parsed.success
@@ -137,7 +145,9 @@ export const entryRunner = (registration) => {
                     arguments: toJsonSchema(input),
                 }), app?.errors);
         });
-        if (recording && (result.isError || partialOutcome(result.structuredContent))) {
+        // The connection a session opens for this call is recorded under the same caller.
+        const result = await (caller ? withCaller(caller, work) : work());
+        if (recording) {
             if (result.isError) {
                 const error = result.structuredContent?.error;
                 const code = error?.code && errorCodes.includes(error.code)

package/dist/runs/events.d.ts

@@ -2,10 +2,12 @@
  * One operation against the messenger, as both sinks see it: `--trace` renders it, a recorded run
  * writes it as a line of JSON.
  *
- * ⚠ **Nothing here may carry content.** An operation name, an id, a count, a duration and an error
- * code are safe. A chat title, a name, a message body, a phone number or a token are not — not
- * truncated and not hashed. The adapter builds `ids` and `counts` from fields it names, never by
- * copying a request, and never from what the person typed: a typed chat is often a title.
+ * ⚠ **Nothing here may carry content.** An operation name, an id, a file or folder path, a count, a duration and an
+ * error code are safe: a run record stays on the owner's machine, and keeping the ids that tell runs apart was the
+ * owner's choice (NEED-110, 2026-10-27). A chat title, a name, a message body, a phone number, a token, a URL as sent
+ * or a query string are not — not truncated and not hashed. The adapter builds `ids` and `counts` from fields it names,
+ * never by copying a request, and never from what the person typed: a typed chat is often a title. Anything that
+ * leaves the machine (a bug report) strips the ids too.
  */
 export interface RequestEvent {
     event: "request" | "response";
@@ -30,6 +32,16 @@ export interface RequestEvent {
     errorCode?: string;
     /** The messenger's own name for a refusal, when it is shaped like one (`providerErrorKey`). */
     providerError?: string;
+    /**
+     * `operation` for one adapter call (`observed`), `wire` for one call on the network under it. A run counts wire
+     * requests when it has any, so one operation over three frames is three requests, never four.
+     */
+    level?: "operation" | "wire";
+    transport?: "http" | "mtproto" | "max-ws" | "wa-engine";
+    /** 1 for the first try, 2 and up for a retry of the same call. */
+    attempt?: number;
+    /** How long the client waited before this attempt: a flood wait or a `Retry-After`. */
+    waitMs?: number;
 }
 /** Something the client noticed and went on without. A code, never the sentence. */
 export interface WarningEvent {

package/dist/runs/events.js

@@ -28,6 +28,10 @@ export const renderEvent = (event) => {
             parts.push([event.method, event.endpointTemplate].filter(Boolean).join(" "));
         if (event.status !== undefined)
             parts.push(`${event.status}`);
+        if (event.attempt !== undefined && event.attempt > 1)
+            parts.push(`attempt ${event.attempt}`);
+        if (event.waitMs !== undefined)
+            parts.push(`waited ${age(event.waitMs)}`);
     }
     if (event.ids)
         for (const [name, value] of Object.entries(event.ids))

package/dist/runs/log-attributes.js

@@ -16,6 +16,10 @@ const diagnostic = {
     outcome: true,
     errorCode: true,
     providerError: true,
+    level: true,
+    transport: true,
+    attempt: true,
+    waitMs: true,
     code: true,
     detail: true,
     reason: true,
@@ -63,12 +67,14 @@ const background = [
 ];
 /** A crash: where it happened, never what it said. */
 const crash = ["errorClass", "frames"];
+/** What a capped run did not write: how many, by operation. */
+const dropped = ["dropped"];
 /**
  * Every attribute key cli-core's writers log, as written: snake_case (`logAttributes`). `createRecordLog`
  * blanks any other, cli-base's own camelCase list included.
  */
 export const LOG_ATTRIBUTES = [
-    ...new Set([...Object.keys(diagnostic), ...Object.keys(send), ...background, ...crash].map((key) => Object.keys(logAttributes({ [key]: true }))[0])),
+    ...new Set([...Object.keys(diagnostic), ...Object.keys(send), ...background, ...crash, ...dropped].map((key) => Object.keys(logAttributes({ [key]: true }))[0])),
 ].sort();
 /** For `cli-dev lint --schemas`, under the name `log_attributes`. */
 export const logAttributesSchema = () => logAttributesJsonSchema(LOG_ATTRIBUTES);

package/dist/runs/log-events.js

@@ -10,6 +10,11 @@ export const CORE_LOG_EVENTS = defineLogEvents([
         keys: ["operation", "reason"],
     },
     { id: "command.crashed", meaning: "a command failed on a bug; where, never what", keys: ["error_class", "frames"] },
+    {
+        id: "events.dropped",
+        meaning: "the run reached its cap and counted the rest instead of writing them",
+        keys: ["dropped", "counts"],
+    },
     { id: "send.recorded", meaning: "a write the send guard saw, and how it ended", keys: ["outcome"] },
     { id: "job.start", meaning: "a background job started", keys: ["job"] },
     { id: "job.exit", meaning: "a background job ended", keys: ["job", "outcome"] },

package/dist/runs/recording.d.ts

@@ -18,6 +18,8 @@ export interface RecordingOptions {
     env?: NodeJS.ProcessEnv;
     runsDir?: string;
     keepDays?: number;
+    keepSuccessDays?: number;
+    maxBytes?: number;
     now?: () => Date;
     /** The caller's trace; otherwise the enclosing run's, otherwise `TRACEPARENT` from `env`. */
     traceId?: string;
@@ -27,13 +29,15 @@ export interface RecordingOptions {
      */
     processRun?: boolean;
     /** The whole command, its masked arguments and the agent that started it. */
-    context?: RunContext;
+    context?: RunContext & {
+        argvIfFailed?: string[];
+    };
 }
 /**
  * Runs one command with the diagnostics turned on, and **finalizes on every path**.
  *
- * `--trace` shows each event as it happens and keeps nothing, `--record` keeps it and shows
- * nothing. It is a wrapper rather than three lines in each command because the failure it prevents
+ * `--trace` shows each event as it happens; the run is kept as the config says — every run unless
+ * `record: false`, which keeps failures only. It is a wrapper rather than three lines in each command because the failure it prevents
  * is the quiet one: a run directory left saying `running` because the command threw on the way out.
  */
 export declare const recorded: <T>(options: RecordingOptions, body: (events: EventSink) => Promise<T>) => Promise<T>;
@@ -49,6 +53,9 @@ export interface Recording {
 /** `recorded` in two halves, for a caller that starts a run before its command and ends it after (max-cli's `max bot`). */
 export declare const startRecording: (options: RecordingOptions) => Recording;
 export declare const wasSettled: (error: unknown) => boolean;
+/** A run of a loop that never ends must not fill the disk: past these, events are counted by operation instead. */
+export declare const EVENTS_AT_MOST = 2000;
+export declare const EVENT_BYTES_AT_MOST: number;
 /**
  * Where a crash happened, not what it said: the class and up to ten frames as `function file:line`,
  * paths cut to the package's own (`framesOf`). **Never `message`** in an event — it can hold whatever the

package/dist/runs/recording.js

@@ -9,8 +9,8 @@ import { enclosingTraceId, inRun, traceOf, useAsProcessRun } from "./scope.js";
 /**
  * Runs one command with the diagnostics turned on, and **finalizes on every path**.
  *
- * `--trace` shows each event as it happens and keeps nothing, `--record` keeps it and shows
- * nothing. It is a wrapper rather than three lines in each command because the failure it prevents
+ * `--trace` shows each event as it happens; the run is kept as the config says — every run unless
+ * `record: false`, which keeps failures only. It is a wrapper rather than three lines in each command because the failure it prevents
  * is the quiet one: a run directory left saying `running` because the command threw on the way out.
  */
 export const recorded = async (options, body) => {
@@ -22,6 +22,7 @@ export const recorded = async (options, body) => {
             startedAt: Date.now(),
             ...(options.profile === undefined ? {} : { profile: options.profile }),
             ...(recording.traceId ? { traceId: recording.traceId } : {}),
+            events: recording.events,
         };
         if (options.processRun)
             useAsProcessRun(scope);
@@ -41,6 +42,7 @@ export const startRecording = (options) => {
     const startedAt = now();
     const runId = newRunId(startedAt, options.command);
     const traceId = options.traceId ?? enclosingTraceId() ?? traceOf(options.env ?? process.env).traceId;
+    const { argvIfFailed, ...context } = options.context ?? {};
     const open = (extra = {}) => startRun({
         runsDir: options.runsDir ?? runsDirFor(options.app, options.env),
         runId,
@@ -49,7 +51,7 @@ export const startRecording = (options) => {
         service: options.app.command,
         cliVersion: options.app.version,
         ...(traceId === undefined ? {} : { traceId }),
-        ...(options.context ? { context: options.context } : {}),
+        ...(options.context ? { context } : {}),
         // The operation has happened or is under way, and failing the command now invites a retry
         // that sends twice.
         onError: (error) => {
@@ -57,47 +59,65 @@ export const startRecording = (options) => {
             streams.diagnostic(options.format === "pretty" ? warning : JSON.stringify({ warning }));
         },
         ...(options.keepDays === undefined ? {} : { keepDays: options.keepDays }),
+        ...(options.keepSuccessDays === undefined ? {} : { keepSuccessDays: options.keepSuccessDays }),
+        ...(options.maxBytes === undefined ? {} : { maxBytes: options.maxBytes }),
         now,
         ...extra,
     });
-    const run = options.record ? open({ startedAt }) : undefined;
+    const run = options.record ? open({ startedAt, lazy: true }) : undefined;
     // Unrecorded, the newest events are held until the outcome is known, so a failure can still be kept.
     const held = !run && options.keepFailed ? [] : undefined;
-    let requests = 0;
+    const counted = { wire: 0, operation: 0 };
     let refused;
+    const cap = capped();
+    const requests = () => (counted.wire > 0 ? counted.wire : counted.operation);
     const events = (event) => {
         if (event.event === "request")
-            requests += 1;
+            counted[event.level === "wire" ? "wire" : "operation"] += 1;
         if (event.event === "response" && event.outcome === "error")
             refused = event;
         if (options.trace)
             streams.diagnostic(options.format === "pretty" ? renderEvent(event) : JSON.stringify(logAttributes(event)));
         if (run)
-            logEvent(run, event);
+            cap.log(run, event);
         if (held) {
             held.push(event);
             if (held.length > HELD_AT_MOST)
                 held.shift();
         }
     };
+    const keep = (kept) => {
+        for (const event of held ?? [])
+            cap.log(kept, event);
+        return kept;
+    };
     return {
         runId,
         ...(traceId === undefined ? {} : { traceId }),
         events,
         succeed: async (answer) => {
             const partial = partialOutcome(answer);
-            const kept = run ?? (partial && held ? keep(open({ startedAt }), held) : undefined);
-            await kept?.finish(partial ? "partial" : "success", { requests, ...(partial ? { partial } : {}) });
+            const kept = run ?? (partial && held ? keep(open({ startedAt })) : undefined);
+            if (kept)
+                cap.close(kept);
+            await kept?.finish(partial ? "partial" : "success", {
+                requests: requests(),
+                ...cap.dropped(),
+                ...(partial ? { partial } : {}),
+            });
         },
         fail: async (error) => {
-            const failed = run ?? (held ? keep(open({ startedAt }), held) : undefined);
+            const failed = run ?? (held ? keep(open({ startedAt })) : undefined);
             if (failed) {
                 if (!isCliFailure(error))
                     failed.logger.error(crashOf(error));
+                cap.close(failed);
                 await failed.finish("failed", {
-                    requests,
+                    requests: requests(),
+                    ...cap.dropped(),
                     ...outcomeOf(error),
                     error: errorDetailOf(error, refused),
+                    ...(argvIfFailed ? { argv: argvIfFailed } : {}),
                     ...(run ? {} : { keptBecauseFailed: true }),
                 });
             }
@@ -110,10 +130,34 @@ export const startRecording = (options) => {
 const settled = new WeakSet();
 export const wasSettled = (error) => typeof error === "object" && error !== null && settled.has(error);
 const HELD_AT_MOST = 500;
-const keep = (run, events) => {
-    for (const event of events)
-        logEvent(run, event);
-    return run;
+/** A run of a loop that never ends must not fill the disk: past these, events are counted by operation instead. */
+export const EVENTS_AT_MOST = 2000;
+export const EVENT_BYTES_AT_MOST = 1024 * 1024;
+const capped = () => {
+    let lines = 0;
+    let bytes = 0;
+    let dropped = 0;
+    const byOperation = {};
+    return {
+        log: (run, event) => {
+            // The record's own envelope (time, ids of the run, resource) is about 200 bytes on top of its attributes.
+            const size = JSON.stringify(logAttributes(event)).length + 200;
+            if (lines >= EVENTS_AT_MOST || bytes + size > EVENT_BYTES_AT_MOST) {
+                dropped += 1;
+                const operation = "operation" in event && event.operation ? event.operation : event.event;
+                byOperation[operation] = (byOperation[operation] ?? 0) + 1;
+                return;
+            }
+            lines += 1;
+            bytes += size;
+            logEvent(run, event);
+        },
+        close: (run) => {
+            if (dropped > 0)
+                run.logger.warn({ event: "events.dropped", dropped, counts: byOperation });
+        },
+        dropped: () => (dropped > 0 ? { eventsDropped: dropped } : {}),
+    };
 };
 const logEvent = (run, event) => {
     const record = {

package/dist/runs/run-context.d.ts

@@ -7,7 +7,54 @@ export interface RunAgent {
     session_id: string | null;
     /** Set, and only `true`, when a chat message started the agent's turn; who sent it is never kept. */
     from_chat?: true;
+    /** The MCP client that made the call, as it named itself; `id` is `clientHash` of an OAuth client's id. */
+    client?: RunClient;
 }
+export interface RunClient {
+    name: string;
+    version?: string;
+    id?: string;
+}
+/** `record_input`: the words typed are kept (`true`), masked (`false`), or kept only in a run that failed. */
+export type RecordInput = boolean | "failed";
+/**
+ * Whether a run that succeeds is kept. Every run is, unless the config says `record: false` — then only failures —
+ * or WireCat Desktop ran the command for its own pages (`WIRECAT_CALLER=desktop`), or the command runs until stopped
+ * (`watch`, `serve`, `mcp`): those two only on `--record`. An MCP call is the caller's run, not Desktop's.
+ */
+export declare const keepsSuccess: ({ record, fromFlag, env, caller, persistent, }: {
+    record: boolean;
+    fromFlag: boolean;
+    env: NodeJS.ProcessEnv;
+    caller?: RunCaller | undefined;
+    persistent?: boolean;
+}) => boolean;
+/** How the run was asked for: typed or scripted, an MCP client on stdio or over HTTP, or WireCat Desktop. */
+export type RunVia = "cli" | "mcp-stdio" | "mcp-http" | "desktop";
+/** The MCP call a run answered. `connection_id` groups the calls of one connection when no agent session does. */
+export interface RunMcp {
+    tool: string;
+    request_id?: string;
+    connection_id?: string;
+    /** The every-profile server passed the call on; the caller is the one it named. */
+    proxied?: true;
+}
+/** Who asked for a run, worked out by whoever received the call; it wins over the process's environment. */
+export interface RunCaller {
+    via: RunVia;
+    agent?: RunAgent;
+    mcp?: RunMcp;
+}
+/**
+ * Runs one MCP call with its caller known, so every run opened under it names that caller: the command's own, and
+ * the connection a server opens for it, which runs under the server's context.
+ */
+export declare const withCaller: <T>(caller: RunCaller, work: () => T) => T;
+export declare const currentCaller: () => RunCaller | undefined;
+/** An OAuth client id is a bearer of sorts: a run keeps eight hex characters of its SHA-256, enough to tell apps apart. */
+export declare const clientHash: (id: string) => string;
+/** `WIRECAT_CALLER=desktop` is set by WireCat Desktop on the commands it runs for its own pages. */
+export declare const viaOf: (env: NodeJS.ProcessEnv) => RunVia;
 /**
  * The agent is read from what each one sets in the processes it starts: Claude Code `CLAUDECODE` and
  * `CLAUDE_CODE_SESSION_ID`, Codex `CODEX_THREAD_ID`, OpenCode `OPENCODE` and `OPENCODE_SESSION_ID`, Hermes
@@ -43,13 +90,17 @@ export declare const maskArgv: (program: Command, words: readonly string[], { ke
  * that calls `recorded` or `startRecording` for a command of its own passes this as `context`; without it the run
  * keeps no command line and no agent.
  */
-export declare const runContextOf: ({ bin, command, program, argv, env, recordInput, }: {
+export declare const runContextOf: ({ bin, command, program, argv, env, recordInput, caller, }: {
     bin: string;
     /** The run's own name, `messages list` or `mcp messages list`; empty when no command was recognised. */
     command: string;
     program?: Command;
     argv?: readonly string[];
     env: NodeJS.ProcessEnv;
-    /** The owner's `record_input`; left out, every value that may be content is masked. */
-    recordInput?: boolean;
-}) => RunContext;
+    /** The owner's `record_input`; left out, every value that may be content is masked. `failed` keeps them only then. */
+    recordInput?: RecordInput | undefined;
+    /** Who asked, when the receiver knows better than the environment: an MCP call. */
+    caller?: RunCaller | undefined;
+}) => RunContext & {
+    argvIfFailed?: string[];
+};

package/dist/runs/run-context.js

@@ -1,7 +1,34 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
 import { isContentKey } from "@wirecat/cli-base/standards";
 import { BARE_PHONE, INTERNATIONAL_PHONE } from "./error-detail.js";
 import { secretNamed, withoutSecrets } from "./secrets.js";
 export const REDACTED = "[redacted]";
+/**
+ * Whether a run that succeeds is kept. Every run is, unless the config says `record: false` — then only failures —
+ * or WireCat Desktop ran the command for its own pages (`WIRECAT_CALLER=desktop`), or the command runs until stopped
+ * (`watch`, `serve`, `mcp`): those two only on `--record`. An MCP call is the caller's run, not Desktop's.
+ */
+export const keepsSuccess = ({ record, fromFlag, env, caller, persistent = false, }) => {
+    if (!record)
+        return false;
+    if (fromFlag)
+        return true;
+    if (persistent)
+        return false;
+    return caller !== undefined || viaOf(env) !== "desktop";
+};
+const calls = new AsyncLocalStorage();
+/**
+ * Runs one MCP call with its caller known, so every run opened under it names that caller: the command's own, and
+ * the connection a server opens for it, which runs under the server's context.
+ */
+export const withCaller = (caller, work) => calls.run(caller, work);
+export const currentCaller = () => calls.getStore();
+/** An OAuth client id is a bearer of sorts: a run keeps eight hex characters of its SHA-256, enough to tell apps apart. */
+export const clientHash = (id) => createHash("sha256").update(id).digest("hex").slice(0, 8);
+/** `WIRECAT_CALLER=desktop` is set by WireCat Desktop on the commands it runs for its own pages. */
+export const viaOf = (env) => (env.WIRECAT_CALLER?.trim() === "desktop" ? "desktop" : "cli");
 /**
  * The agent is read from what each one sets in the processes it starts: Claude Code `CLAUDECODE` and
  * `CLAUDE_CODE_SESSION_ID`, Codex `CODEX_THREAD_ID`, OpenCode `OPENCODE` and `OPENCODE_SESSION_ID`, Hermes
@@ -176,13 +203,17 @@ const safeShape = (value) => (NUMBER.test(value) && !/^\d{11,}$/.test(value)) ||
  * that calls `recorded` or `startRecording` for a command of its own passes this as `context`; without it the run
  * keeps no command line and no agent.
  */
-export const runContextOf = ({ bin, command, program, argv, env, recordInput = false, }) => {
-    const masked = program && argv ? maskArgv(program, argv, { keep: recordInput }) : undefined;
-    const agent = agentOf(env);
+export const runContextOf = ({ bin, command, program, argv, env, recordInput = false, caller, }) => {
+    const masked = program && argv ? maskArgv(program, argv, { keep: recordInput === true }) : undefined;
+    const ifFailed = program && argv && recordInput === "failed" ? maskArgv(program, argv, { keep: true }) : undefined;
+    const agent = caller ? caller.agent : agentOf(env);
     return {
         cliCommand: command ? `${bin} ${command}` : bin,
         ...(masked ? { argv: masked.argv } : {}),
+        ...(ifFailed ? { argvIfFailed: ifFailed.argv } : {}),
         ...(masked?.unknownCommand === undefined ? {} : { unknownCommand: masked.unknownCommand }),
         ...(agent ? { agent } : {}),
+        via: caller?.via ?? viaOf(env),
+        ...(caller?.mcp ? { mcp: caller.mcp } : {}),
     };
 };