@wirecat/cli-core 0.466.0 → 0.467.0

package/dist/cli/settings.js

@@ -5,6 +5,7 @@ import { AI_ENTRIES, resolveAISettings } from "../analysis/settings.js";
 import { parseDuration } from "../domain/duration.js";
 import { DEFAULT_RERANK_MODEL, RERANK_MODELS } from "../embeddings/models.js";
 import { envName, readOnlyLockOf } from "../ports/app.js";
+import { KEEP_SUCCESSFUL_RUNS_FOR_DAYS, RUNS_SIZE_LIMIT_MB } from "../runs/run.js";
 import { assertOverridesTighten, CEILING_KEY, COMMAND_PATH_KEY, LEVELS, layerPermissions, permissionOverrides, RESOURCE_KEY, RESOURCES, } from "../sends/permissions.js";
 import { storePath } from "../store/path.js";
 import { sharedConfigPath } from "../store/shared-config.js";
@@ -33,6 +34,8 @@ export const count = v.pipe(v.number(wholeNumber), v.integer(wholeNumber), v.min
 const zeroOrMore = plain("has to be a whole number, 0 or more");
 const countOrZero = v.pipe(v.number(zeroOrMore), v.integer(zeroOrMore), v.minValue(0, zeroOrMore));
 export const flag = v.boolean(plain("has to be true or false"));
+/** `record_input`: true, false, or "failed" — the words typed kept only in a run that failed. */
+export const recordInputSetting = v.union([v.boolean(), v.literal("failed")], plain('has to be true, false or "failed"'));
 const wholeOrZero = (text, name) => {
     const value = Number(text);
     if (!Number.isInteger(value) || value < 0)
@@ -58,8 +61,10 @@ const SHARED_PROFILE_ENTRIES = {
     color: v.optional(flag),
     sender_colors: v.optional(flag),
     record: v.optional(flag),
-    record_input: v.optional(flag),
+    record_input: v.optional(recordInputSetting),
     keep_runs_for_days: v.optional(count),
+    keep_successful_runs_for_days: v.optional(count),
+    runs_size_limit_mb: v.optional(count),
     permissions: v.optional(permissionLevels),
     sends_per_hour: v.optional(count),
     requests_per_minute: v.optional(countOrZero),
@@ -232,7 +237,7 @@ export const settingsFor = (app, extension = {}) => {
         const fromLayers = (key, fallback, only = layers) => first(only.map(([from, scope]) => [from, scope?.[key]]), fallback);
         const kindLayers = layers.filter(([from]) => from.startsWith(`config file: ${kind}.`));
         const limit = flags.limit === undefined ? fromLayers("limit", DEFAULT_LIMIT) : { value: flags.limit, from: "flag" };
-        const record = flags.record === undefined ? fromLayers("record", false) : { value: flags.record, from: "flag" };
+        const record = flags.record === undefined ? fromLayers("record", true) : { value: flags.record, from: "flag" };
         const timeoutMs = fromLayers("timeout_ms", undefined);
         const color = fromLayers("color", undefined);
         const senderColors = fromLayers("sender_colors", false);
@@ -241,6 +246,8 @@ export const settingsFor = (app, extension = {}) => {
         const searchReranker = fromLayers("search_reranker", DEFAULT_RERANK_MODEL);
         const recordInput = fromLayers("record_input", true);
         const keepRunsForDays = fromLayers("keep_runs_for_days", DEFAULT_KEEP_RUNS_FOR_DAYS);
+        const keepSuccessfulRunsForDays = fromLayers("keep_successful_runs_for_days", KEEP_SUCCESSFUL_RUNS_FOR_DAYS);
+        const runsSizeLimitMb = fromLayers("runs_size_limit_mb", RUNS_SIZE_LIMIT_MB);
         // Set where an agent runs unattended; the config file and `--permission` cannot undo it.
         const readOnlyLock = readOnlyLockOf(app, env);
         // A bot has no hourly limit unless the bot section gives it one: a bot that answers people is
@@ -297,8 +304,10 @@ export const settingsFor = (app, extension = {}) => {
                 : (extension.parseDuration ?? parseDuration)(timeout.value, timeout.from === TIMEOUT ? TIMEOUT : "--timeout"),
             record: record.value,
             recordInput: recordInput.value,
-            keepFailedRuns: record.value || record.from === "default",
+            keepFailedRuns: record.value || record.from !== "flag",
             keepRunsForDays: keepRunsForDays.value,
+            keepSuccessfulRunsForDays: keepSuccessfulRunsForDays.value,
+            runsSizeLimitMb: runsSizeLimitMb.value,
             ...(readOnlyLock ? { readOnlyLock } : {}),
             permissions: permissions.levels,
             permissionSources: permissions.sources,
@@ -326,6 +335,8 @@ export const settingsFor = (app, extension = {}) => {
                 record: record.from,
                 recordInput: recordInput.from,
                 keepRunsForDays: keepRunsForDays.from,
+                keepSuccessfulRunsForDays: keepSuccessfulRunsForDays.from,
+                runsSizeLimitMb: runsSizeLimitMb.from,
                 sendsPerHour: sendsPerHour.from,
                 requestsPerMinute: requestsPerMinute.from,
                 readOtherBots: readOtherBots.from,

package/dist/cli/shared-command-exports.d.ts

@@ -79,8 +79,10 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
             color: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sender_colors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
-            record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            record_input: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").BooleanSchema<undefined>, import("valibot").LiteralSchema<"failed", undefined>], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            keep_successful_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            runs_size_limit_mb: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").GenericSchema<string>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             requests_per_minute: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 0, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
@@ -153,8 +155,10 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
             color: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sender_colors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
-            record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            record_input: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").BooleanSchema<undefined>, import("valibot").LiteralSchema<"failed", undefined>], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            keep_successful_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            runs_size_limit_mb: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").GenericSchema<string>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             requests_per_minute: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 0, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
@@ -283,8 +287,10 @@ export declare const completeCommand: (messenger: import("./index.js").Messenger
             color: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sender_colors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
-            record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            record_input: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").BooleanSchema<undefined>, import("valibot").LiteralSchema<"failed", undefined>], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            keep_successful_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            runs_size_limit_mb: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").GenericSchema<string>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             requests_per_minute: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 0, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
@@ -357,8 +363,10 @@ export declare const completeCommand: (messenger: import("./index.js").Messenger
             color: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sender_colors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
-            record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            record_input: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").BooleanSchema<undefined>, import("valibot").LiteralSchema<"failed", undefined>], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            keep_successful_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            runs_size_limit_mb: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").GenericSchema<string>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             requests_per_minute: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 0, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;

package/dist/entities/index.d.ts

@@ -6312,7 +6312,20 @@ export declare const ENTITIES: {
             readonly kind: v.StringSchema<undefined>;
             readonly session_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly from_chat: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+            readonly client: v.OptionalSchema<v.StrictObjectSchema<{
+                readonly name: v.StringSchema<undefined>;
+                readonly version: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
         }, undefined>, undefined>;
+        readonly via: v.OptionalSchema<v.PicklistSchema<["cli", "mcp-stdio", "mcp-http", "desktop"], undefined>, undefined>;
+        readonly mcp: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly tool: v.StringSchema<undefined>;
+            readonly request_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly connection_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly proxied: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly events_dropped: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly error: v.OptionalSchema<v.StrictObjectSchema<{
             readonly class: v.StringSchema<undefined>;
             readonly code: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
@@ -6375,7 +6388,20 @@ export declare const ENTITIES: {
             readonly kind: v.StringSchema<undefined>;
             readonly session_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly from_chat: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+            readonly client: v.OptionalSchema<v.StrictObjectSchema<{
+                readonly name: v.StringSchema<undefined>;
+                readonly version: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly via: v.OptionalSchema<v.PicklistSchema<["cli", "mcp-stdio", "mcp-http", "desktop"], undefined>, undefined>;
+        readonly mcp: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly tool: v.StringSchema<undefined>;
+            readonly request_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly connection_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly proxied: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
         }, undefined>, undefined>;
+        readonly events_dropped: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly error: v.OptionalSchema<v.StrictObjectSchema<{
             readonly class: v.StringSchema<undefined>;
             readonly code: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
@@ -6437,7 +6463,20 @@ export declare const ENTITIES: {
             readonly kind: v.StringSchema<undefined>;
             readonly session_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly from_chat: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+            readonly client: v.OptionalSchema<v.StrictObjectSchema<{
+                readonly name: v.StringSchema<undefined>;
+                readonly version: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly via: v.OptionalSchema<v.PicklistSchema<["cli", "mcp-stdio", "mcp-http", "desktop"], undefined>, undefined>;
+        readonly mcp: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly tool: v.StringSchema<undefined>;
+            readonly request_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly connection_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly proxied: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
         }, undefined>, undefined>;
+        readonly events_dropped: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly error: v.OptionalSchema<v.StrictObjectSchema<{
             readonly class: v.StringSchema<undefined>;
             readonly code: v.OptionalSchema<v.StringSchema<undefined>, undefined>;

package/dist/entities/recorded-run.d.ts

@@ -35,7 +35,20 @@ export declare const recordedRun: v.StrictObjectSchema<{
         readonly kind: v.StringSchema<undefined>;
         readonly session_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly from_chat: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+        readonly client: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly name: v.StringSchema<undefined>;
+            readonly version: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly via: v.OptionalSchema<v.PicklistSchema<["cli", "mcp-stdio", "mcp-http", "desktop"], undefined>, undefined>;
+    readonly mcp: v.OptionalSchema<v.StrictObjectSchema<{
+        readonly tool: v.StringSchema<undefined>;
+        readonly request_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly connection_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly proxied: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
     }, undefined>, undefined>;
+    readonly events_dropped: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     readonly error: v.OptionalSchema<v.StrictObjectSchema<{
         readonly class: v.StringSchema<undefined>;
         readonly code: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
@@ -98,7 +111,20 @@ export declare const runDetails: v.StrictObjectSchema<{
         readonly kind: v.StringSchema<undefined>;
         readonly session_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly from_chat: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+        readonly client: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly name: v.StringSchema<undefined>;
+            readonly version: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
     }, undefined>, undefined>;
+    readonly via: v.OptionalSchema<v.PicklistSchema<["cli", "mcp-stdio", "mcp-http", "desktop"], undefined>, undefined>;
+    readonly mcp: v.OptionalSchema<v.StrictObjectSchema<{
+        readonly tool: v.StringSchema<undefined>;
+        readonly request_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly connection_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly proxied: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly events_dropped: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     readonly error: v.OptionalSchema<v.StrictObjectSchema<{
         readonly class: v.StringSchema<undefined>;
         readonly code: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
@@ -160,7 +186,20 @@ export declare const runHit: v.StrictObjectSchema<{
         readonly kind: v.StringSchema<undefined>;
         readonly session_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly from_chat: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+        readonly client: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly name: v.StringSchema<undefined>;
+            readonly version: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly via: v.OptionalSchema<v.PicklistSchema<["cli", "mcp-stdio", "mcp-http", "desktop"], undefined>, undefined>;
+    readonly mcp: v.OptionalSchema<v.StrictObjectSchema<{
+        readonly tool: v.StringSchema<undefined>;
+        readonly request_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly connection_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly proxied: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
     }, undefined>, undefined>;
+    readonly events_dropped: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     readonly error: v.OptionalSchema<v.StrictObjectSchema<{
         readonly class: v.StringSchema<undefined>;
         readonly code: v.OptionalSchema<v.StringSchema<undefined>, undefined>;

package/dist/entities/recorded-run.js

@@ -28,7 +28,20 @@ export const recordedRun = v.strictObject({
     cli_command: v.optional(text),
     argv: v.optional(v.array(text)),
     unknown_command: v.optional(text),
-    agent: v.optional(v.strictObject({ kind: text, session_id: v.nullable(text), from_chat: v.optional(v.literal(true)) })),
+    agent: v.optional(v.strictObject({
+        kind: text,
+        session_id: v.nullable(text),
+        from_chat: v.optional(v.literal(true)),
+        client: v.optional(v.strictObject({ name: text, version: v.optional(text), id: v.optional(text) })),
+    })),
+    via: v.optional(v.picklist(["cli", "mcp-stdio", "mcp-http", "desktop"])),
+    mcp: v.optional(v.strictObject({
+        tool: text,
+        request_id: v.optional(text),
+        connection_id: v.optional(text),
+        proxied: v.optional(v.literal(true)),
+    })),
+    events_dropped: v.optional(count),
     error: v.optional(v.strictObject({
         class: text,
         code: v.optional(text),

package/dist/mcp/agent.d.ts

@@ -7,6 +7,7 @@ export type { CommandAvailability } from "../cli/command-availability.js";
 import type { RunOptions } from "../cli/program.js";
 import type { StdinField } from "../cli/stdin-field.js";
 import type { MessengerAdapter } from "../ports/messenger.js";
+import type { RunCaller } from "../runs/run-context.js";
 import { type Level, type PermissionKey } from "../sends/permissions.js";
 /** The CLI's own `run` — a fresh program on every call — and its command tree as `commands --json` describes it. */
 export interface AgentProgram {
@@ -32,6 +33,8 @@ export interface AgentContext {
     stdin?: (path: readonly string[]) => StdinField | undefined;
     /** More of the run's environment, read by the commands that look for it: the server's `spawnJob`, `embedders`. */
     environment?: Readonly<Record<string, unknown>>;
+    /** Who made the call (`callerOf`); the run records it rather than this server's environment. */
+    caller?: RunCaller;
 }
 export type AgentAnswer = {
     result: unknown;

package/dist/mcp/agent.js

@@ -8,6 +8,7 @@ import { commandAvailability } from "../cli/command-availability.js";
 import { changesMessenger } from "../cli/effects.js";
 import { lentConnection } from "../cli/messenger/serve-relay.js";
 import { authorityAllowed, botApiAllowed } from "../sends/permissions.js";
+import { currentCaller } from "./caller.js";
 const TYPES = new Map(VOCABULARY.flags.map((flag) => [flag.name, flag.type]));
 // `<name|id>` is one argument: its field is `name_or_id`.
 const snake = (name) => name.replaceAll("|", "_or_").replace(/[^a-z0-9]+/gi, "_");
@@ -231,6 +232,7 @@ export const runCommandForAgent = async (program, path, input, ctx) => {
                 ...(ctx.overrides?.length ? { overrides: ctx.overrides } : {}),
                 authority: levels !== undefined && authorityAllowed(levels),
                 botApi: levels !== undefined && botApiAllowed(levels),
+                ...((ctx.caller ?? currentCaller()) ? { caller: ctx.caller ?? currentCaller() } : {}),
             },
             // Opened only when the command asks: a read the store answers never connects.
             ...(lend

package/dist/mcp/all-profiles.d.ts

@@ -25,6 +25,8 @@ export interface AllProfilesOptions {
     idleMs?: number;
     /** A child's stderr, line by line; never this process's stdout, which carries the protocol. */
     note?: (line: string) => void;
+    /** This server's environment, which names the agent that started it on stdio; `process.env` when left out. */
+    env?: NodeJS.ProcessEnv;
 }
 /**
  * The child's tool with the one field that picks the profile, required and without a default. Each profile carries

package/dist/mcp/all-profiles.js

@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/server";
 import { StdioServerTransport, serveStdio } from "@modelcontextprotocol/server/stdio";
+import { CALLER_META_KEY, callerOf, PROXY_CLIENT_NAME } from "./caller.js";
 import { answeredWire } from "./stdio-wire.js";
 const PROTOCOL = "2025-06-18";
 const START_MS = 30_000;
@@ -82,7 +84,7 @@ const startChild = (spec, note, onExit) => {
     return request("initialize", {
         protocolVersion: PROTOCOL,
         capabilities: {},
-        clientInfo: { name: "all-profiles", version: "1" },
+        clientInfo: { name: PROXY_CLIENT_NAME, version: "1" },
     })
         .then(() => {
         send({ method: "notifications/initialized" });
@@ -202,7 +204,12 @@ export const allProfilesServer = (options) => {
                 ? []
                 : (await tools(profiles)).map((one) => withProfile(one, profiles, options.name, signedIn)),
         }));
-        server.server.setRequestHandler("tools/call", async (request) => {
+        const callers = {
+            env: options.env ?? process.env,
+            client: () => server.server.getClientVersion(),
+            connectionId: randomUUID(),
+        };
+        server.server.setRequestHandler("tools/call", async (request, ctx) => {
             const { name, arguments: given = {}, _meta } = request.params;
             const { profile, ...rest } = given;
             if (typeof profile !== "string" || !profiles.includes(profile))
@@ -210,7 +217,13 @@ export const allProfilesServer = (options) => {
             if (!signedIn(profile))
                 return refusal(options.signIn?.(profile) ?? `profile ${profile} is not signed in.`);
             try {
-                return (await children.use(profile, (child) => child.request("tools/call", { name, arguments: rest, ...(_meta ? { _meta } : {}) })));
+                return (await children.use(profile, (child) => 
+                // Children are shared by every session, so each call names its own caller.
+                child.request("tools/call", {
+                    name,
+                    arguments: rest,
+                    _meta: { ..._meta, [CALLER_META_KEY]: callerOf(ctx, name, callers) },
+                })));
             }
             catch (error) {
                 return refusal(`profile ${profile}: ${error instanceof Error ? error.message : String(error)}`);

package/dist/mcp/bot/server.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { mcpErrorResult } from "@wirecat/cli-base";
@@ -9,6 +10,7 @@ import { itemOf } from "../../cli/envelope.js";
 import { wholeList } from "../../cli/messenger/chat-answers.js";
 import { MESSENGER_CHANGE_REFUSAL, readOnlyLockOf, readOnlyRefusal } from "../../ports/app.js";
 import { runCommandForAgent, toolsFromCommands } from "../agent.js";
+import { callerOf } from "../caller.js";
 import { normal, registerCommands } from "../surface.js";
 import { agentJson } from "../text.js";
 import { answered } from "../tool.js";
@@ -48,7 +50,7 @@ export const createBotServer = (options) => {
     const skill = options.skill ? skillResource(bot.app, options.skill) : undefined;
     // One at a time: the commands share the journal, the registry and the local copy.
     let queue = Promise.resolve();
-    const invoke = (path, input) => {
+    const invoke = (path, input, caller) => {
         const next = queue.then(() => runCommandForAgent(program, path, path[0] === "config" ? { ...input, bot: true } : input, {
             profile: settings.profile,
             readOnly: readOnlyLockOf(bot.app, env) !== undefined,
@@ -56,11 +58,13 @@ export const createBotServer = (options) => {
             levels,
             ...(options.keyOf ? { keyOf: options.keyOf } : {}),
             authority,
+            ...(caller ? { caller } : {}),
         }));
         queue = next.catch(() => undefined);
         return next;
     };
     const build = () => {
+        const callers = { env, client: () => server.server.getClientVersion(), connectionId: randomUUID() };
         const server = new McpServer({ name: `${command}-bot-${settings.profile}`, version: bot.app.version }, {
             instructions: botInstructions({
                 command,
@@ -82,8 +86,9 @@ export const createBotServer = (options) => {
                 writes: tool.writes,
                 availability: tool.availability,
                 input: tool.input,
-                run: async (args) => {
-                    const answer = await invoke(tool.path, args);
+                run: async (args, ctx) => {
+                    const caller = callerOf(ctx, `${command}_${tool.command.replaceAll(" ", "_")}`, callers);
+                    const answer = await invoke(tool.path, args, caller);
                     return "error" in answer
                         ? mcpErrorResult(JSON.parse(agentJson(answer.error)))
                         : answered(body(tool.command, answer.result));

package/dist/mcp/caller.d.ts

@@ -0,0 +1,38 @@
+import { type RunCaller } from "../runs/run-context.js";
+export { currentCaller, withCaller } from "../runs/run-context.js";
+/** The `_meta` key the every-profile server names the real caller under, for the profile server it passes a call to. */
+export declare const CALLER_META_KEY = "wirecat.dev/caller";
+/** The name the every-profile server gives itself in `initialize`; only a connection from it may name a caller. */
+export declare const PROXY_CLIENT_NAME = "all-profiles";
+/** What a tool call's handler is given, reduced to what identifies the caller. */
+export interface CallContext {
+    sessionId?: string | undefined;
+    mcpReq?: {
+        id?: string | number;
+        _meta?: Record<string, unknown> | undefined;
+    } | undefined;
+    http?: {
+        authInfo?: {
+            clientId: string;
+            extra?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | undefined;
+}
+export interface CallerSource {
+    /** This server's environment: the coding agent that started a stdio server. Never read for an HTTP call. */
+    env: NodeJS.ProcessEnv;
+    /** The client's `initialize`, when this connection had one. */
+    client?: () => {
+        name: string;
+        version?: string;
+    } | undefined;
+    /** One id per stdio connection, made when the server starts. */
+    connectionId?: string;
+}
+/**
+ * Who made one MCP call. Over HTTP the server's own environment is somebody else's — whoever started `mcp --http` —
+ * so the caller is the OAuth client (its registered name and a hash of its id) and the HTTP session, if any. Over
+ * stdio the agent that started the server is the caller, and `initialize` names its client. A call the every-profile
+ * server passed on carries the caller it worked out, trusted only on a connection that server opened.
+ */
+export declare const callerOf: (ctx: CallContext | undefined, tool: string, source: CallerSource) => RunCaller;

package/dist/mcp/caller.js

@@ -0,0 +1,95 @@
+import { CLIENT_INFO_META_KEY } from "@modelcontextprotocol/server";
+import { agentOf, clientHash } from "../runs/run-context.js";
+export { currentCaller, withCaller } from "../runs/run-context.js";
+/** The `_meta` key the every-profile server names the real caller under, for the profile server it passes a call to. */
+export const CALLER_META_KEY = "wirecat.dev/caller";
+/** The name the every-profile server gives itself in `initialize`; only a connection from it may name a caller. */
+export const PROXY_CLIENT_NAME = "all-profiles";
+const NAME = /^[\w .@()/+-]{1,64}$/;
+const plain = (value) => typeof value === "string" && NAME.test(value.trim()) ? value.trim() : undefined;
+const clientFrom = (value) => {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const { name, version } = value;
+    const named = plain(name);
+    if (!named)
+        return undefined;
+    const versioned = plain(version);
+    return { name: named, ...(versioned ? { version: versioned } : {}) };
+};
+/**
+ * Who made one MCP call. Over HTTP the server's own environment is somebody else's — whoever started `mcp --http` —
+ * so the caller is the OAuth client (its registered name and a hash of its id) and the HTTP session, if any. Over
+ * stdio the agent that started the server is the caller, and `initialize` names its client. A call the every-profile
+ * server passed on carries the caller it worked out, trusted only on a connection that server opened.
+ */
+export const callerOf = (ctx, tool, source) => {
+    const meta = ctx?.mcpReq?._meta;
+    const requestId = ctx?.mcpReq?.id;
+    const initialized = source.client?.();
+    const proxied = initialized?.name === PROXY_CLIENT_NAME ? passedOn(meta?.[CALLER_META_KEY], tool) : undefined;
+    if (proxied)
+        return proxied;
+    const client = clientFrom(meta?.[CLIENT_INFO_META_KEY]) ?? clientFrom(initialized);
+    const mcp = (connection) => ({
+        tool,
+        ...(requestId === undefined ? {} : { request_id: String(requestId) }),
+        ...(connection ? { connection_id: connection } : {}),
+    });
+    const auth = ctx?.http?.authInfo;
+    if (auth) {
+        const registered = plain(auth.extra?.clientName);
+        return {
+            via: "mcp-http",
+            agent: {
+                kind: "mcp-client",
+                session_id: ctx?.sessionId ?? null,
+                client: {
+                    name: registered ?? client?.name ?? "unknown",
+                    ...(client?.version ? { version: client.version } : {}),
+                    id: clientHash(auth.clientId),
+                },
+            },
+            mcp: mcp(ctx?.sessionId),
+        };
+    }
+    const agent = agentOf(source.env) ?? { kind: "mcp-client", session_id: null };
+    return { via: "mcp-stdio", agent: { ...agent, ...(client ? { client } : {}) }, mcp: mcp(source.connectionId) };
+};
+/** The caller the every-profile server named, field by field: nothing else it sent reaches a run. */
+const passedOn = (value, tool) => {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const { via, agent, mcp } = value;
+    if (via !== "mcp-stdio" && via !== "mcp-http")
+        return undefined;
+    const a = agent && typeof agent === "object" ? agent : undefined;
+    const kind = plain(a?.kind);
+    const session = typeof a?.session_id === "string" && /^[A-Za-z0-9._:-]{1,128}$/.test(a.session_id) ? a.session_id : null;
+    const client = clientFrom(a?.client);
+    const id = a?.client && typeof a.client === "object" ? a.client.id : undefined;
+    const m = mcp && typeof mcp === "object" ? mcp : {};
+    const request = plain(m.request_id);
+    const connection = typeof m.connection_id === "string" && /^[\w-]{1,128}$/.test(m.connection_id) ? m.connection_id : undefined;
+    return {
+        via,
+        ...(kind
+            ? {
+                agent: {
+                    kind,
+                    session_id: session,
+                    ...(a?.from_chat === true ? { from_chat: true } : {}),
+                    ...(client
+                        ? { client: { ...client, ...(typeof id === "string" && /^[0-9a-f]{8}$/.test(id) ? { id } : {}) } }
+                        : {}),
+                },
+            }
+            : {}),
+        mcp: {
+            tool,
+            ...(request ? { request_id: request } : {}),
+            ...(connection ? { connection_id: connection } : {}),
+            proxied: true,
+        },
+    };
+};

package/dist/mcp/http/oauth.js

@@ -258,15 +258,19 @@ export const ownerLogin = ({ issuer, resource, file, appName, onCode, now = () =
     const verifier = {
         verifyAccessToken: async (presented) => {
             const seconds = Math.floor(now() / 1000);
-            const found = store.read().tokens.find((one) => one.kind === "access" && one.hash === hash(presented));
+            const stored = store.read();
+            const found = stored.tokens.find((one) => one.kind === "access" && one.hash === hash(presented));
             if (!found || found.expiresAt <= seconds)
                 throw new OAuthError(OAuthErrorCode.InvalidToken, "the token is unknown or expired");
+            // The name the app registered with, so a run can say which app called; the id itself never leaves here unhashed.
+            const clientName = stored.clients.find((one) => one.id === found.clientId)?.name;
             return {
                 token: presented,
                 clientId: found.clientId,
                 scopes: [],
                 expiresAt: found.expiresAt,
                 resource,
+                ...(clientName ? { extra: { clientName } } : {}),
             };
         },
     };