@wirecat/cli-core 0.466.0 → 0.468.0

package/CHANGELOG.md

@@ -5,6 +5,70 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
+## Unreleased
+
+## 0.468.0 — 27.10.2026
+
+### Changed — may break callers
+
+- **An MCP server offers a command that only fetches into the store through its read tool.** A command that reads
+  the provider and only keeps what it read in the owner's store (`effects: { remote: "read", local: "write" }`,
+  `FETCH`) — `contacts sync`, `metadata sync`, `chats members fetch`, a calendar's `sync` and `calendars list` — is
+  now `writes: false` in the catalogue and runs with `<cli>_read`; `<cli>_write` refuses it and names `_read` (owner
+  ruling, 2026-10-27; WC-CMD-17). These stay writes: a local edit (`changesStore`, `tags rebuild`), an authority
+  change (`grantsAuthority`, `recipients add`), a call to another service (`reachesOtherService`), a command that
+  saves files (named `download`, or with a folder to write into: `messages download`, `models download`,
+  `attachments extract --output-dir`), and anything that changes the provider. Permissions do not change: a
+  `readonly` level still refuses a fetch. New `fetchesOnly(command)` and `fetchesOnlyAt(root)`; `toolsFromCommands`
+  takes `fetchOnly`, and without it every write stays one (a CLI with its own server passes
+  `fetchOnly: fetchesOnlyAt(program)`). A CLI's `contracts/mcp-catalogue.json` changes where it has such commands.
+- **A CLI that is not a messenger (`AppIdentity.messenger: false`) no longer offers messenger settings.** `config
+  set|unset` lists and takes neither `sends_per_hour`, `sender_colors`, `transcribe_with`, `search_catch_up` and
+  `read_other_bots` (`settingsFor(...).allSettings` leaves them out; a file that has one is still read) nor the store
+  settings of messages — `phone_countries`, `task_*` and `account_groups.<name>` — which it would have changed for
+  tg and MAX. `search_stemmers.*` stays. `config show` leaves the same profile settings out.
+- **A model that is not downloaded names its download as the error's `next` step, only in a CLI that has the
+  command.** The `model.not-downloaded` error of a text model said `` `<cli> models download <id>` `` in its message,
+  also in a CLI without `models` (gcal). Its message is now `<id> is not downloaded on this machine`; the step
+  (`models.download`, or `models.download-image` for a picture model) comes as `error.next` with its `line`, the
+  profile in it, and only where the program has the command. Any error's `next` is now dropped when it names a
+  command the program lacks.
+- **`skill show` offers `follow-ups` and `link-conversations` only in a messenger CLI.** Both work on chats.
+
+## 0.467.0 — 27.10.2026
+
+### Changed — may break callers
+
+- **Every run is now recorded by default, successes too** — before, only failures were kept unless `--record` or
+  `record: true`. Successful runs are kept 7 days (`keep_successful_runs_for_days`), failures 30
+  (`keep_runs_for_days`), and the runs folder stays under `runs_size_limit_mb` (200; the oldest successes go
+  first, checked once a day). **Privacy:** with `record_input` on, as by default since 0.439.0, every successful
+  `send` now leaves its typed words (message text, a chat typed by title) in a local, 0600 run record for 7 days.
+  `record: false` restores failures only; `record_input: "failed"` keeps the typed words only in a run that failed;
+  `record_input: false` masks them everywhere; `--no-record` keeps nothing. A success that logged no events is one
+  line in the day's index, with no folder; `runs show` finds it there. MCP tools keep successes too. A command that
+  runs until stopped (`watch`, `serve`, `mcp`) and a command WireCat Desktop runs for itself
+  (`WIRECAT_CALLER=desktop`) keep a success only under `--record`. Search history still follows `record`.
+- **A run says who asked for it.** `run.json` gains `via` (`cli`, `mcp-stdio`, `mcp-http`, `desktop`), `mcp`
+  (`tool`, `request_id`, `connection_id`, `proxied`) and `agent.client` (`name`, `version`, and over HTTP `id`, the
+  first 8 hex of the SHA-256 of the OAuth client id). Over HTTP the agent is `mcp-client` with the
+  `Mcp-Session-Id` as its session, never the environment of whoever started `mcp --http`: such runs were credited to
+  that agent before. The `run`, `run.details` and `run.hit` answer shapes declare the new fields. The every-profile server names the real caller to the profile server in
+  `_meta["wirecat.dev/caller"]`; a profile server trusts it only on a connection that server opened.
+- **Request events gain `level`, `transport`, `attempt` and `wait_ms`**, and `requests` counts wire calls when a
+  transport logs them, otherwise operations. `providerRequest` takes a third argument with the call's method, path
+  template, transport, attempt, wait and bytes. A run writes at most 2,000 events or 1 MB, then one
+  `events.dropped` line and `events_dropped`. `runEvent` reaches the current run from a wire layer handed no sink. A
+  retry made above the transport (`patiently`, the bot APIs' rate-limit wait) marks the calls under it with
+  `withAttempt`, so their lines say `attempt: 2` and the wait. Events logged after a run finished — a long-running
+  server's connection — are dropped rather than written into it.
+- **`record: false` in the config now keeps failures**; before, it kept nothing. `--no-record` still keeps nothing.
+
+### Fixed
+
+- **`doctor reports create` labels the ids a run's metadata keeps** — the agent session, the OAuth client id, the
+  MCP connection and request, the trace and a failed chat — as it already labelled the events' ids.
+
 ## 0.466.0 — 27.10.2026
 
 ### Changed — may break callers

package/README.md

@@ -218,8 +218,10 @@ they deliberately differ. A rule changes in its own pull request, before the cod
 - **The tool never picks an account.** Every account command names its profile — the first word in tg, max and
   wa, an option such as `--account` or `--profile` in the others; without one, the command stops and lists the
   choices — even when there is only one.
-- **Run records keep the command as typed, never a secret.** A failure is kept by default, so `runs show` can explain
-  it; a token, a password or a phone number is hidden, and `record_input: false` leaves the typed words out too.
+- **Run records keep the command as typed, never a secret.** Every run is kept, with one line per request it made,
+  so `runs show` can explain it: successes for 7 days, failures for 30, within a size limit. A token, a password or
+  a phone number is hidden; `record_input: false` leaves the typed words out, `"failed"` keeps them only for a
+  failure, and `record: false` keeps failures only.
 - **Tests that cannot touch real data.** A sandbox keeps every test away from the owner's store, and no test may
   sleep. A coverage floor: 92% of lines, and at least half of every file.
 - **Contract cases for every adapter.** `contractCases` turns the port's promises into cases any test runner can run,

package/dist/cli/bot/mcp.js

@@ -3,7 +3,7 @@ import { CliError } from "@wirecat/cli-base";
 import { annotate, describeProgram } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { environmentOf } from "../context.js";
-import { changesAuthorityAt, LOCAL_READ, REMOTE_WRITE } from "../effects.js";
+import { changesAuthorityAt, fetchesOnlyAt, LOCAL_READ, REMOTE_WRITE } from "../effects.js";
 import { itemOf, renderAnswer } from "../envelope.js";
 import { serverEntry } from "../messenger/mcp-command.js";
 import { nextStep, rootOf } from "../steps.js";
@@ -37,6 +37,7 @@ export const botMcpCommand = (bot) => {
             bot,
             program: { run, commands: describeProgram(rootOf(this)) },
             authority: changesAuthorityAt(rootOf(this)),
+            fetchOnly: fetchesOnlyAt(rootOf(this)),
             settings: context.settings,
             levels: () => bot.resolveSettings(this.optsWithGlobals(), { env: context.env, kind: "bot" }).permissions,
             env: context.env,

package/dist/cli/command-runs.d.ts

@@ -1,20 +1,28 @@
 import { type RenderFormat, type Streams } from "@wirecat/cli-base";
 import type { Command } from "commander";
 import type { AppIdentity } from "../ports/app.js";
-import type { RequestEvent } from "../runs/events.js";
-/** What the owner saved: `record` and `keep_runs_for_days`, read from the CLI's own config. */
+import { type RequestEvent } from "../runs/events.js";
+import { type RecordInput } from "../runs/run-context.js";
+/** What the owner saved, read from the CLI's own config: `record`, `record_input` and how long runs are kept. */
 export interface SavedRunSettings {
     record?: boolean | undefined;
     keepRunsForDays?: number | undefined;
+    keepSuccessfulRunsForDays?: number | undefined;
+    runsSizeLimitMb?: number | undefined;
     /** `record_input`: left out, the typed words are kept, secrets hidden. */
-    recordInput?: boolean | undefined;
+    recordInput?: RecordInput | undefined;
 }
 export interface RunSettings {
     record: boolean;
     keepFailedRuns: boolean;
     keepRunsForDays: number;
+    keepSuccessfulRunsForDays: number;
+    runsSizeLimitMb: number;
 }
-/** `--record`/`--no-record` first, then the config; a failure is kept unless either says no (WC-LIFE-15). */
+/**
+ * `--record`/`--no-record` first, then the config: every run is kept unless it says `record: false`, which keeps
+ * failures only; `--no-record` keeps nothing (WC-LIFE-15).
+ */
 export declare const runSettings: (flag: boolean | undefined, saved?: SavedRunSettings) => RunSettings;
 export interface CommandRunOptions {
     app: AppIdentity;
@@ -47,17 +55,37 @@ export interface CommandRuns {
     events(event: RequestEvent): void;
 }
 export declare const commandRuns: (options: CommandRunOptions) => CommandRuns;
-/** For a provider client far from the program: the event lands in the current command's run, or nowhere. */
-export declare const providerEvent: (event: RequestEvent) => void;
 /**
- * Times one provider call under a fixed operation name — nothing the call carries goes into the run. The returned
- * function ends it; an `error` or an `errorCode` makes it a failed one.
+ * For a provider client far from the program: the event lands in the current command's run — a `startCli` command's,
+ * or the run `run()` opened — or nowhere.
  */
-export declare const providerRequest: (operation: string, sink?: (event: RequestEvent) => void) => ({ status, error, errorCode }?: {
+export declare const providerEvent: (event: RequestEvent) => void;
+/** What one wire call was, besides its operation: never the URL as sent, its query or its body. */
+export interface ProviderCall {
+    method?: string;
+    /** The path with ids as `:id`, `/v2/users/:id/meetings`; `endpointTemplate` cuts anything past it. */
+    endpointTemplate?: string;
+    transport?: RequestEvent["transport"];
+    /** 1 for the first try; a retry passes 2 and up, with the wait before it. */
+    attempt?: number;
+    waitMs?: number;
+    bytes?: number;
+}
+export interface ProviderAnswer {
     status?: number;
     error?: unknown;
     errorCode?: string;
-}) => void;
+    /** The service's own name for a refusal, `rateLimitExceeded`; dropped unless shaped like one. */
+    providerError?: string;
+    bytes?: number;
+    counts?: Record<string, number>;
+    ids?: Record<string, string>;
+}
+/**
+ * Times one wire call under a fixed operation name — nothing the call carries goes into the run. The returned
+ * function ends it; an `error` or an `errorCode` makes it a failed one.
+ */
+export declare const providerRequest: (operation: string, sink?: (event: RequestEvent) => void, call?: ProviderCall) => ({ status, error, errorCode, providerError, bytes, counts, ids }?: ProviderAnswer) => void;
 /**
  * WC-LIFE-15 for a CLI with its own commander program (`startCli`, not `run()`): adds `--record` and `--no-record`,
  * keeps every failed command as a run — a usage error before any action too — and every command when recording is

package/dist/cli/command-runs.js

@@ -1,17 +1,25 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { isCliError } from "@wirecat/cli-base";
+import { metaOf } from "@wirecat/cli-base/commands";
+import { providerErrorKey } from "../runs/events.js";
 import { startRecording, wasSettled } from "../runs/recording.js";
-import { KEEP_RUNS_FOR_DAYS } from "../runs/run.js";
-import { runContextOf } from "../runs/run-context.js";
+import { KEEP_RUNS_FOR_DAYS, KEEP_SUCCESSFUL_RUNS_FOR_DAYS, RUNS_SIZE_LIMIT_MB } from "../runs/run.js";
+import { keepsSuccess, runContextOf } from "../runs/run-context.js";
+import { currentAttempt, runEvent } from "../runs/scope.js";
 import { environmentOf } from "./context.js";
 import { rootOf } from "./profile.js";
-/** `--record`/`--no-record` first, then the config; a failure is kept unless either says no (WC-LIFE-15). */
+/**
+ * `--record`/`--no-record` first, then the config: every run is kept unless it says `record: false`, which keeps
+ * failures only; `--no-record` keeps nothing (WC-LIFE-15).
+ */
 export const runSettings = (flag, saved = {}) => {
-    const record = flag ?? saved.record ?? false;
+    const record = flag ?? saved.record ?? true;
     return {
         record,
-        keepFailedRuns: record || (flag !== false && saved.record !== false),
+        keepFailedRuns: record || flag !== false,
         keepRunsForDays: saved.keepRunsForDays ?? KEEP_RUNS_FOR_DAYS,
+        keepSuccessfulRunsForDays: saved.keepSuccessfulRunsForDays ?? KEEP_SUCCESSFUL_RUNS_FOR_DAYS,
+        runsSizeLimitMb: saved.runsSizeLimitMb ?? RUNS_SIZE_LIMIT_MB,
     };
 };
 const SKIPPED = new Set(["runs", "help"]);
@@ -23,7 +31,7 @@ const pathOf = (command) => {
 };
 const tracker = (options, typed) => {
     let recording;
-    const open = (program, words, flag, format) => {
+    const open = (program, words, flag, format, lifetime) => {
         recording = undefined;
         // Reading the log is not worth a run of its own.
         if (SKIPPED.has(words[0] ?? ""))
@@ -46,13 +54,22 @@ const tracker = (options, typed) => {
         const streams = options.streams ?? environment.streams;
         const env = options.env ?? environment.env;
         const command = `${agent ? "mcp " : ""}${words.join(" ") || options.app.command}`;
+        const caller = environment.agent?.caller;
         recording = startRecording({
             app: options.app,
             command,
             ...(profile === undefined ? {} : { profile }),
-            record: settings.record,
+            record: keepsSuccess({
+                record: settings.record,
+                fromFlag: flag !== undefined,
+                env: env ?? process.env,
+                caller,
+                persistent: lifetime === "persistent",
+            }),
             keepFailed: settings.keepFailedRuns,
             keepDays: settings.keepRunsForDays,
+            keepSuccessDays: settings.keepSuccessfulRunsForDays,
+            maxBytes: settings.runsSizeLimitMb * 1024 * 1024,
             trace: false,
             format,
             ...(streams ? { streams } : {}),
@@ -63,7 +80,8 @@ const tracker = (options, typed) => {
                 program: rootOf(program),
                 ...((environment.argv ?? typed) ? { argv: environment.argv ?? typed } : {}),
                 env: env ?? process.env,
-                recordInput: saved.recordInput !== false,
+                recordInput: saved.recordInput ?? true,
+                caller,
             }),
         });
     };
@@ -76,7 +94,7 @@ const tracker = (options, typed) => {
         start(action) {
             const flags = action.optsWithGlobals();
             const json = (flags.json !== undefined && flags.json !== false) || Boolean(flags.jsonl);
-            open(action, pathOf(action), flags.record, options.format?.() ?? (json ? "json" : "pretty"));
+            open(action, pathOf(action), flags.record, options.format?.() ?? (json ? "json" : "pretty"), metaOf(action).lifetime);
         },
         async succeed() {
             await finish()?.succeed();
@@ -91,24 +109,40 @@ const tracker = (options, typed) => {
 };
 export const commandRuns = (options) => tracker(options);
 const parses = new AsyncLocalStorage();
-/** For a provider client far from the program: the event lands in the current command's run, or nowhere. */
-export const providerEvent = (event) => parses.getStore()?.runs.events(event);
 /**
- * Times one provider call under a fixed operation name — nothing the call carries goes into the run. The returned
+ * For a provider client far from the program: the event lands in the current command's run — a `startCli` command's,
+ * or the run `run()` opened — or nowhere.
+ */
+export const providerEvent = (event) => {
+    const parse = parses.getStore();
+    if (parse)
+        parse.runs.events(event);
+    else
+        runEvent(event);
+};
+/**
+ * Times one wire call under a fixed operation name — nothing the call carries goes into the run. The returned
  * function ends it; an `error` or an `errorCode` makes it a failed one.
  */
-export const providerRequest = (operation, sink = providerEvent) => {
-    sink({ event: "request", operation });
+export const providerRequest = (operation, sink = providerEvent, call = {}) => {
+    const { bytes: sent, ...shape } = call;
+    const wire = { operation, level: "wire", ...(call.attempt === undefined ? currentAttempt() : {}), ...shape };
+    sink({ event: "request", ...wire, ...(sent === undefined ? {} : { bytes: sent }) });
     const started = performance.now();
-    return ({ status, error, errorCode } = {}) => {
+    return ({ status, error, errorCode, providerError, bytes, counts, ids } = {}) => {
         const failed = error !== undefined || errorCode !== undefined;
+        const key = providerErrorKey(providerError);
         sink({
             event: "response",
-            operation,
+            ...wire,
             ...(status === undefined ? {} : { status }),
             durationMs: Math.round(performance.now() - started),
             outcome: failed ? "error" : "ok",
             ...(failed ? { errorCode: errorCode ?? (isCliError(error) ? error.code : "provider_error") } : {}),
+            ...(key ? { providerError: key } : {}),
+            ...(bytes === undefined ? {} : { bytes }),
+            ...(counts ? { counts } : {}),
+            ...(ids ? { ids } : {}),
         });
     };
 };
@@ -144,7 +178,7 @@ const isHelpExit = (error) => {
  */
 export const recordRuns = (program, options) => {
     program
-        .option("--record", "keep this run, with the command as typed and secrets hidden; record_input false leaves the typed words out")
+        .option("--record", "keep this run even where the config says record false; record_input false leaves the typed words out")
         .option("--no-record", "do not keep this run, even if it fails");
     program.hook("preAction", (_root, action) => {
         const parse = parses.getStore();

package/dist/cli/config-command.d.ts

@@ -2,6 +2,10 @@ import { Command } from "commander";
 import { type AppIdentity } from "../ports/app.js";
 import { type PermissionKeySource } from "./permission-keys.js";
 import { type Configuration } from "./settings.js";
+/**
+ * The settings in force and where each came from, and changing them. Printed whole: no field the
+ * configuration accepts can hold a secret — the schema has nowhere to put one.
+ */
 export declare const configCommand: (app: AppIdentity, config: Configuration, { permissionKey }?: {
     permissionKey?: PermissionKeySource | undefined;
 }) => Command;

package/dist/cli/config-command.js

@@ -9,13 +9,11 @@ import { itemOf, renderAnswer } from "./envelope.js";
 import { knownBeside, knownPermissionKeys, unknownPermissionIssues, } from "./permission-keys.js";
 import { fromFile, NONE_NAMED } from "./settings.js";
 import { nextStep } from "./steps.js";
-import { changeStoreSetting, isStoreSetting, STORE_SETTINGS, storeSettings } from "./store-settings.js";
+import { changeStoreSetting, isStoreSetting, offersStoreSetting, storeSettings, storeSettingsOf, } from "./store-settings.js";
 /**
  * The settings in force and where each came from, and changing them. Printed whole: no field the
  * configuration accepts can hold a secret — the schema has nowhere to put one.
  */
-/** `sender_colors` colours who wrote a message; a CLI without messages has nothing to colour. */
-const shownSettings = (app, config) => app.messenger === false ? config.allSettings.filter((setting) => setting !== "sender_colors") : config.allSettings;
 export const configCommand = (app, config, { permissionKey = config.permissions } = {}) => {
     const command = new Command("config").description("the settings in force, and where each one came from");
     annotate(command.command("show"), { effects: LOCAL_READ, examples: [`${app.command} personal config show`] })
@@ -38,7 +36,7 @@ export const configCommand = (app, config, { permissionKey = config.permissions
             config_file: settings.configPath,
             config_found: settings.configFound,
             paths_overridden: overridden,
-            settings: [...shownSettings(app, config), "command_timeout_ms"]
+            settings: [...config.allSettings, "command_timeout_ms"]
                 .filter((setting) => bot || setting !== "read_other_bots")
                 .map((setting) => sourced(settings, setting)),
             store_settings: await storeSettings(env),
@@ -58,7 +56,7 @@ export const configCommand = (app, config, { permissionKey = config.permissions
             effects: LOCAL_WRITE,
             examples: [`${app.command} personal config ${action} limit${action === "set" ? " 20" : ""}`],
         }))
-            .argument("<setting>", `one of: ${[...shownSettings(app, config), ...STORE_SETTINGS, "account_groups.<name>"].join(", ")}`)
+            .argument("<setting>", `one of: ${[...config.allSettings, ...storeSettingsOf(app)].join(", ")}`)
             .option("--defaults", "change what every profile gets, rather than this profile")
             .option("--personal", "only for personal accounts — the personal section of the file")
             .option("--bot", "only for bots — the bot section of the file");
@@ -72,6 +70,8 @@ export const configCommand = (app, config, { permissionKey = config.permissions
             const { defaults: everyone, personal, bot, } = this.opts();
             const context = baseContext(this, (flags, options) => config.resolveSettings(flags, { ...options, needsProfile: false, withIssues: true }));
             const { settings, renderer, env } = context;
+            if (isStoreSetting(setting) && !offersStoreSetting(app, setting))
+                throw new CliError("validation_error", `no setting called "${setting}" here — it belongs to the messenger CLIs; one of: ${[...config.allSettings, ...storeSettingsOf(app)].join(", ")}`);
             if (isStoreSetting(setting)) {
                 if (everyone || personal || bot)
                     throw new CliError("validation_error", `${setting} is store-wide — --defaults, --personal and --bot do not apply`);

package/dist/cli/context.d.ts

@@ -6,6 +6,7 @@ import type { MessageEvent } from "../domain/models.js";
 import type { AppIdentity } from "../ports/app.js";
 import type { MessengerAdapter } from "../ports/messenger.js";
 import type { EventSink } from "../runs/events.js";
+import { type RunCaller } from "../runs/run-context.js";
 import type { OpenRecognizer } from "../speech/transcribe.js";
 import type { SecretInput } from "../terminal/prompt.js";
 import { type Closeable } from "./deadline.js";
@@ -95,6 +96,8 @@ export interface AgentRun {
     authority?: boolean;
     /** The server's levels allow `bot.api`: a raw Bot API call, past the send guard, may run. */
     botApi?: boolean;
+    /** Who made the MCP call, as the server received it; the run records it instead of the server's environment. */
+    caller?: RunCaller;
 }
 export interface RelayedRun {
     /** The profile serve holds; a command for another is refused before it touches the connection. */

package/dist/cli/context.js

@@ -1,8 +1,9 @@
 import { CliError } from "@wirecat/cli-base";
+import { metaOf } from "@wirecat/cli-base/commands";
 import { runBudget } from "../background/budget.js";
 import { resolveOutput } from "../output.js";
 import { recorded } from "../runs/recording.js";
-import { runContextOf } from "../runs/run-context.js";
+import { currentCaller, keepsSuccess, runContextOf } from "../runs/run-context.js";
 import { withDeadline } from "./deadline.js";
 import { withAbort } from "./execution.js";
 import { rootOf } from "./profile.js";
@@ -101,13 +102,24 @@ export const baseContext = (command, resolveSettings) => {
                     program: rootOf(command),
                     ...(environment.argv ? { argv: environment.argv } : {}),
                     env,
-                    recordInput: settings.recordInput !== false,
+                    recordInput: settings.recordInput ?? true,
+                    caller: environment.agent?.caller ?? currentCaller(),
                 }),
                 ...(ranFor === undefined ? {} : { profile: ranFor }),
-                record: settings.record,
+                record: keepsSuccess({
+                    record: settings.record,
+                    fromFlag: settings.sources?.record === "flag",
+                    env,
+                    caller: environment.agent?.caller ?? currentCaller(),
+                    persistent: metaOf(command).lifetime === "persistent",
+                }),
                 keepFailed: settings.keepFailedRuns,
                 trace: settings.trace,
                 keepDays: settings.keepRunsForDays,
+                ...(settings.keepSuccessfulRunsForDays === undefined
+                    ? {}
+                    : { keepSuccessDays: settings.keepSuccessfulRunsForDays }),
+                ...(settings.runsSizeLimitMb === undefined ? {} : { maxBytes: settings.runsSizeLimitMb * 1024 * 1024 }),
                 processRun: !environment.agent,
                 format,
                 streams,

package/dist/cli/effects.d.ts

@@ -41,6 +41,15 @@ export declare const isLogin: (command: Command) => boolean;
 export declare const destroysNothing: <T extends Command>(command: T) => T;
 /** A local edit remains an edit even when it first fetches metadata from the messenger. */
 export declare const changesStore: <T extends Command>(command: T) => T;
+/**
+ * Reads the provider and only keeps what it read in the owner's store — a sync, a list that refreshes it. An MCP server
+ * offers it through the read tool (owner ruling, 2026-10-27; WC-CMD-17): it changes nothing at the provider or for
+ * other people. A local edit (`changesStore`), an authority change, a call to another service (`reachesOtherService`,
+ * a model download) and a command that saves files (a download, a folder to write into) stay writes.
+ */
+export declare const fetchesOnly: (command: Command) => boolean;
+/** `fetchesOnly` by command path under `root`, as an MCP catalogue asks it; an unknown path is not one. */
+export declare const fetchesOnlyAt: (root: Command) => (path: readonly string[]) => boolean;
 /**
  * Whether `<PREFIX>_READ_ONLY` refuses the command as a change to the store. Every write that stays on this machine
  * is refused unless `destroysNothing` marks it, so a new one fails closed (WC-PERM-12). A fetch (`remote: "read"`)

package/dist/cli/effects.js

@@ -66,6 +66,33 @@ export const changesStore = (command) => {
     STORE_WRITES.add(command);
     return command;
 };
+/** A download or a folder to write into: files outside the store, which the owner places, not an agent. */
+const savesFiles = (command) => command.name() === "download" ||
+    [...command.options.map((option) => option.attributeName()), ...command.registeredArguments.map((one) => one.name())]
+        .map((name) => name.toLowerCase())
+        .some((name) => name === "dir" || name.endsWith("dir") || name === "output");
+/**
+ * Reads the provider and only keeps what it read in the owner's store — a sync, a list that refreshes it. An MCP server
+ * offers it through the read tool (owner ruling, 2026-10-27; WC-CMD-17): it changes nothing at the provider or for
+ * other people. A local edit (`changesStore`), an authority change, a call to another service (`reachesOtherService`,
+ * a model download) and a command that saves files (a download, a folder to write into) stay writes.
+ */
+export const fetchesOnly = (command) => {
+    const effects = metaOf(command).effects;
+    return (effects?.remote === "read" &&
+        effects.local === "write" &&
+        !STORE_WRITES.has(command) &&
+        !changesAuthority(command) &&
+        !OTHER_SERVICE.has(command) &&
+        !savesFiles(command));
+};
+/** `fetchesOnly` by command path under `root`, as an MCP catalogue asks it; an unknown path is not one. */
+export const fetchesOnlyAt = (root) => (path) => {
+    let at = root;
+    for (const word of path)
+        at = at?.commands.find((one) => one.name() === word);
+    return at !== undefined && fetchesOnly(at);
+};
 /**
  * Whether `<PREFIX>_READ_ONLY` refuses the command as a change to the store. Every write that stays on this machine
  * is refused unless `destroysNothing` marks it, so a new one fails closed (WC-PERM-12). A fetch (`remote: "read"`)

package/dist/cli/index.d.ts

@@ -26,7 +26,7 @@ export { CORE_LOG_EVENTS } from "../runs/log-events.js";
 export { crashOf, type Recording, type RecordingOptions, recorded, startRecording, wasSettled, } from "../runs/recording.js";
 export { findRun, KEEP_RUNS_FOR_DAYS, listRuns, pruneRuns, type RunContext, type RunMetadata, readEvents, runsDirFor, runtime, startRun, } from "../runs/run.js";
 export { runContextOf, secretInput } from "../runs/run-context.js";
-export { currentRun, inRun, type RunScope, useAsProcessRun } from "../runs/scope.js";
+export { type Attempt, currentAttempt, currentRun, inRun, type RunScope, runEvent, useAsProcessRun, withAttempt, } from "../runs/scope.js";
 export { LANGUAGES } from "../search/languages.js";
 export { guardedApp, guardedPress, guardedStart, type Pressed } from "../sends/buttons.js";
 export { guardedClose, guardedCreatePoll, guardedVote } from "../sends/polls.js";
@@ -52,7 +52,7 @@ export { BotTokenStore, type BotTokenStoreOptions } from "./bot/token.js";
 export { PressLog, UpdatesCursor } from "./bot/updates.js";
 export type { CommandAvailability, DiscoveredCommand } from "./command-availability.js";
 export { commandContract, type JsonSchema, SCHEMA_DIALECT } from "./command-contract.js";
-export { type CommandRunOptions, type CommandRuns, commandRuns, providerEvent, providerRequest, type RunSettings, recordRuns, runSettings, type SavedRunSettings, } from "./command-runs.js";
+export { type CommandRunOptions, type CommandRuns, commandRuns, type ProviderAnswer, type ProviderCall, providerEvent, providerRequest, type RunSettings, recordRuns, runSettings, type SavedRunSettings, } from "./command-runs.js";
 export { CONTRACT } from "./commands-command.js";
 export { refuseUnknownKey } from "./config-command.js";
 export { type ConfigIssue, type ConfigIssueKind, checkConfigText, issueMessage, readConfigFile, readConfigText, settingPathOf, withoutSetting, } from "./config-issues.js";
@@ -63,7 +63,7 @@ export { sharedCommandTemplate } from "./contract-templates.js";
 export { type Closeable, withDeadline } from "./deadline.js";
 export { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
 export { DISCOVERY_DESCRIPTIONS } from "./discovery-descriptions.js";
-export { changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, previewFlag, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, storeChangeRefusal, } from "./effects.js";
+export { changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, fetchesOnly, fetchesOnlyAt, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, previewFlag, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, storeChangeRefusal, } from "./effects.js";
 export { type CliEntry, type EntryContext, type EntryIo, startCli } from "./entry.js";
 export { type AnswerOutput, answerSchema, type Body, type ItemBody, isBody, itemAnswer, itemOf, jsonlRecords, judgedAnswer, type ListBody, type ListInput, listOf, metaNow, printItem, renderAnswer, sealed, snakeKeys, snakeKeysKeeping, } from "./envelope.js";
 export { withAbort } from "./execution.js";

package/dist/cli/index.js

@@ -22,7 +22,7 @@ export { CORE_LOG_EVENTS } from "../runs/log-events.js";
 export { crashOf, recorded, startRecording, wasSettled, } from "../runs/recording.js";
 export { findRun, KEEP_RUNS_FOR_DAYS, listRuns, pruneRuns, readEvents, runsDirFor, runtime, startRun, } from "../runs/run.js";
 export { runContextOf, secretInput } from "../runs/run-context.js";
-export { currentRun, inRun, useAsProcessRun } from "../runs/scope.js";
+export { currentAttempt, currentRun, inRun, runEvent, useAsProcessRun, withAttempt, } from "../runs/scope.js";
 export { LANGUAGES } from "../search/languages.js";
 export { guardedApp, guardedPress, guardedStart } from "../sends/buttons.js";
 export { guardedClose, guardedCreatePoll, guardedVote } from "../sends/polls.js";
@@ -56,7 +56,7 @@ export { sharedCommandTemplate } from "./contract-templates.js";
 export { withDeadline } from "./deadline.js";
 export { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
 export { DISCOVERY_DESCRIPTIONS } from "./discovery-descriptions.js";
-export { changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, previewFlag, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, storeChangeRefusal, } from "./effects.js";
+export { changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, fetchesOnly, fetchesOnlyAt, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, previewFlag, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, storeChangeRefusal, } from "./effects.js";
 export { startCli } from "./entry.js";
 export { answerSchema, isBody, itemAnswer, itemOf, jsonlRecords, judgedAnswer, listOf, metaNow, printItem, renderAnswer, sealed, snakeKeys, snakeKeysKeeping, } from "./envelope.js";
 export { withAbort } from "./execution.js";

package/dist/cli/messenger/context.js

@@ -413,7 +413,7 @@ export const messengerContext = (command, messenger, resolving = {}) => {
                 offline: base.settings.offline,
                 reads: messenger.history ?? "server",
                 // Turning recording off by name (--no-record, or record: false) keeps no search history either.
-                history: base.settings.keepFailedRuns,
+                history: base.settings.record,
                 searchCatchUp: base.settings.searchCatchUp,
                 pictures: base.settings.pictureSearch,
                 reranker: base.settings.searchReranker,

package/dist/cli/messenger/observed.js

@@ -10,12 +10,19 @@ export const observed = (messenger, events) => {
     const timed = async (operation, named, work, after) => {
         const write = currentOperation();
         const marked = (part = {}) => write === undefined ? part : { ...part, ids: { ...part.ids, operation: write } };
-        events({ event: "request", operation, ...marked(named) });
+        events({ event: "request", operation, level: "operation", ...marked(named) });
         const started = performance.now();
         const durationMs = () => Math.round(performance.now() - started);
         try {
             const answer = await work();
-            events({ event: "response", operation, durationMs: durationMs(), outcome: "ok", ...marked(after?.(answer)) });
+            events({
+                event: "response",
+                operation,
+                level: "operation",
+                durationMs: durationMs(),
+                outcome: "ok",
+                ...marked(after?.(answer)),
+            });
             return answer;
         }
         catch (error) {
@@ -23,6 +30,7 @@ export const observed = (messenger, events) => {
             events({
                 event: "response",
                 operation,
+                level: "operation",
                 durationMs: durationMs(),
                 outcome: "error",
                 errorCode: isCliFailure(error) ? error.code : "generic_failure",