@wirecat/cli-core 0.438.0 → 0.440.0

package/CHANGELOG.md

@@ -7,6 +7,60 @@ shape of this file.
 
 ## Unreleased
 
+## 0.440.0 — 26.10.2026
+
+### Added
+
+- **A CLI's own command can keep its command line in its run record.** A command the CLI records itself with
+  `recorded` or `startRecording` kept no `argv` and no agent, since only cli-core's own commands built that part of the
+  record. `runContextOf` and the `RunContext` type are now exported from `@wirecat/cli-core/cli`. To adopt, pass
+  `context: runContextOf({ bin, command, program: rootOf(command), argv: environmentOf(command).argv, env,
+  recordInput: settings.recordInput !== false })` to the call; a CLI with its own program passes its own root command
+  and the words it parsed. Left out, `recordInput` masks every value that may be content. A CLI that records through
+  `commandRuns` under `run()` gets the command line with no change; its `settings()` may return `recordInput`, and when
+  it does not, the typed words are kept with secrets hidden.
+- **`secretInput` also marks a whole command**: every word typed after it that is not an option is `[redacted]` in a
+  run record. For a command that refuses its arguments, such as one that asks for a phone number instead of taking it,
+  this hides what was typed without declaring an argument, so its usage line and contract stay the same.
+
+### Changed — may break callers
+
+- **`--record` help says what a run keeps now.** It read "ids and timings, never content", which stopped being true
+  in 0.439.0; it now reads "keep this run, with the command as typed and secrets hidden; record_input false leaves the
+  typed words out". Every CLI's help snapshot and `docs/commands.md` change with it. `recordRuns` no longer takes
+  `content`, which only that line used.
+
+### Security
+
+- **A phone number no longer reaches a run record.** Since 0.439.0 a run keeps the words as typed, so a number typed
+  after `contacts lookup`, which the command refuses, was kept in `argv` in the clear. The command is now marked with
+  `secretInput`, so every word typed after it is `[redacted]`. A phone number typed anywhere else, message text included, is replaced by `[redacted]` inside the word,
+  the rest kept: one written with its "+" and country code, or 11 to 15 digits in a row, the shapes a kept error
+  already masks. A positive id of 11 to 15 digits, such as an 11-digit Zoom meeting id or a time in milliseconds, is
+  hidden as well; a negative chat id is kept. A number with no "+" written in groups (`8 912 345-67-89`) is not
+  recognised.
+
+## 0.439.0 — 26.10.2026
+
+### Changed — may break callers
+
+- **A run record keeps the command line as typed.** `argv` in `run.json` and `runs show` now holds the words the person
+  typed — a chat's title, a search, message text — so the history of what was run can be read back. A secret is
+  still always `[redacted]`: the value of an option or argument a CLI marks with the new `secretInput(...)` (exported
+  from `@wirecat/cli-core/cli`), one whose name says token, password, secret, credential, cookie, authorization or
+  API key, a password inside a URL, and a long opaque string. `bot api … --body` is marked secret, since a field the
+  API marks secret can ride in it. The new per-profile setting `record_input: false` (`config set record_input false`)
+  brings back the previous masking exactly. A configuration that will not load also masks, since it may be the one
+  that turned recording off. A CLI with its own `resolveSettings` may return `recordInput`; when it does not, typed
+  words are kept. `doctor reports create` still masks the run's words as before, since the report is sent to other
+  people. `config set` and `config show` list `record_input`, so a CLI's help snapshot changes. A test or document
+  that says a run never holds what was typed needs updating.
+
+### Security
+
+- **An error that quotes `--token=…` or `password=…` no longer keeps the value.** A kept error masked such a value
+  only when a space followed the `=` or `:`; Commander's `unknown option '--token=…'` kept it whole.
+
 ## 0.438.0 — 26.10.2026
 
 ### Security

package/README.md

@@ -217,8 +217,8 @@ 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 ids and timings, never content.** A failure is kept by default, so `runs show` can explain it
-  without anyone sending a log full of messages.
+- **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.
 - **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/api.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command, Option } from "commander";
+import { secretInput } from "../../runs/run-context.js";
 import { REMOTE_READ, REMOTE_WRITE } from "../effects.js";
 import { apiFlagOf, apiOptionKey, readApiBody } from "./api-input.js";
 export const generatedApiCommand = (api) => {
@@ -20,7 +21,8 @@ export const generatedApiCommand = (api) => {
             command.addOption(parameter.required && parameter.in !== "body" ? option.makeOptionMandatory() : option);
         }
         if (operation.request) {
-            command.option("--body <json>", "the request body as JSON; - reads it from stdin");
+            // A field the schema marks secret may ride in an inline body, and the flags never see it.
+            command.addOption(secretInput(new Option("--body <json>", "the request body as JSON; - reads it from stdin")));
             command.option("--body-file <path>", "the request body from a JSON file; - is stdin");
         }
         annotate(command, {

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

@@ -6,6 +6,8 @@ import type { RequestEvent } from "../runs/events.js";
 export interface SavedRunSettings {
     record?: boolean | undefined;
     keepRunsForDays?: number | undefined;
+    /** `record_input`: left out, the typed words are kept, secrets hidden. */
+    recordInput?: boolean | undefined;
 }
 export interface RunSettings {
     record: boolean;
@@ -59,6 +61,4 @@ export declare const providerRequest: (operation: string, sink?: (event: Request
  * on. Call it after the program's other `parseAsync` wrappers, so its own is the outermost and sees how the parse
  * really ended; a refusal in an earlier `preAction` hook is then kept under the words read from the line.
  */
-export declare const recordRuns: (program: Command, options: CommandRunOptions & {
-    content: string;
-}) => void;
+export declare const recordRuns: (program: Command, options: CommandRunOptions) => void;

package/dist/cli/command-runs.js

@@ -2,7 +2,9 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { isCliError } from "@wirecat/cli-base";
 import { startRecording, wasSettled } from "../runs/recording.js";
 import { KEEP_RUNS_FOR_DAYS } from "../runs/run.js";
+import { runContextOf } from "../runs/run-context.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). */
 export const runSettings = (flag, saved = {}) => {
     const record = flag ?? saved.record ?? false;
@@ -41,9 +43,10 @@ const tracker = (options) => {
         const agent = options.agent ?? environment.agent !== undefined;
         const streams = options.streams ?? environment.streams;
         const env = options.env ?? environment.env;
+        const command = `${agent ? "mcp " : ""}${words.join(" ") || options.app.command}`;
         recording = startRecording({
             app: options.app,
-            command: `${agent ? "mcp " : ""}${words.join(" ") || options.app.command}`,
+            command,
             ...(profile === undefined ? {} : { profile }),
             record: settings.record,
             keepFailed: settings.keepFailedRuns,
@@ -52,6 +55,14 @@ const tracker = (options) => {
             format,
             ...(streams ? { streams } : {}),
             ...(env ? { env } : {}),
+            context: runContextOf({
+                bin: options.app.command,
+                command: words.length > 0 ? command : "",
+                program: rootOf(program),
+                ...(environment.argv ? { argv: environment.argv } : {}),
+                env: env ?? process.env,
+                recordInput: saved.recordInput !== false,
+            }),
         });
     };
     const finish = () => {
@@ -131,7 +142,7 @@ const isHelpExit = (error) => {
  */
 export const recordRuns = (program, options) => {
     program
-        .option("--record", `keep this run — ids and timings, never ${options.content}`)
+        .option("--record", "keep this run, with the command as typed and secrets hidden; 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/context.d.ts

@@ -62,7 +62,7 @@ export interface BaseEnvironment {
     handled?: (event: MessageEvent) => void;
     /** Set by an MCP server on a command it runs for an agent (`runCommandForAgent`). */
     agent?: AgentRun;
-    /** Set by `run()`: the words it was given, which a run keeps masked (`maskArgv`). */
+    /** Set by `run()`: the words it was given, which a run keeps as `record_input` says (`maskArgv`). */
     argv?: readonly string[];
     /**
      * Set by `run()`: the rest of the command has no default deadline, and Ctrl-C, SIGTERM, a cancel or an explicit

package/dist/cli/context.js

@@ -86,6 +86,7 @@ export const baseContext = (command, resolveSettings) => {
                     program: rootOf(command),
                     ...(environment.argv ? { argv: environment.argv } : {}),
                     env,
+                    recordInput: settings.recordInput !== false,
                 }),
                 ...(ranFor === undefined ? {} : { profile: ranFor }),
                 record: settings.record,

package/dist/cli/index.d.ts

@@ -24,7 +24,8 @@ export { repliesStatePathFor } from "../replies/state.js";
 export { type CacheEvent, type DiagnosticEvent, type EventSink, providerErrorKey, type RequestEvent, renderEvent, type WarningEvent, } from "../runs/events.js";
 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 RunMetadata, readEvents, runsDirFor, runtime, startRun, } from "../runs/run.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 { LANGUAGES } from "../search/languages.js";
 export { guardedApp, guardedPress, guardedStart, type Pressed } from "../sends/buttons.js";

package/dist/cli/index.js

@@ -21,6 +21,7 @@ export { providerErrorKey, renderEvent, } from "../runs/events.js";
 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 { LANGUAGES } from "../search/languages.js";
 export { guardedApp, guardedPress, guardedStart } from "../sends/buttons.js";

package/dist/cli/messenger/contacts-command.js

@@ -3,6 +3,7 @@ import { annotate } from "@wirecat/cli-base/commands";
 import { defineQuery } from "@wirecat/cli-base/query";
 import { Command } from "commander";
 import { REGISTRIES, registriesCover } from "../../botcheck/registries.js";
+import { secretInput } from "../../runs/run-context.js";
 import { levelFor } from "../../sends/permissions.js";
 import { phoneOf } from "../../services/index.js";
 import { dateWindow } from "../../services/moment.js";
@@ -276,7 +277,7 @@ export const contactsCommand = (messenger) => {
      * ⚠ **The number is asked for or piped, never an argument**: argv is read by `ps` and kept by shell
      * history, and a phone number is personal data.
      */
-    annotate(contacts.command("lookup"), { effects: REMOTE_READ, output: { entity: "contact_lookup" } })
+    annotate(secretInput(contacts.command("lookup")), { effects: REMOTE_READ, output: { entity: "contact_lookup" } })
         .summary("find an account by a phone number")
         .description("who has this phone number — asks for it, or reads it from stdin; never an argument")
         // Commander's own refusal would repeat the number on stderr.

package/dist/cli/messenger/doctor-command.js

@@ -14,7 +14,7 @@ import { destroysNothing, LOCAL_WRITE, NO_EFFECTS, REMOTE_READ } from "../effect
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
 import { unknownPermissionIssues } from "../permission-keys.js";
 import { NONE_NAMED } from "../settings.js";
-import { lineOf, nextStep } from "../steps.js";
+import { lineOf, nextStep, rootOf } from "../steps.js";
 import { recalledAccount } from "./accounts.js";
 import { messengerContext } from "./context.js";
 import { privateFiles, withSqliteSidecars } from "./private-files.js";
@@ -100,6 +100,7 @@ const reportCommand = (messenger) => {
             sends: profile ? new SendJournal(sendsPathFor(app, profile, env)).entries() : [],
             now,
             home: env.HOME ?? env.USERPROFILE,
+            program: rootOf(this),
             ...(options.run === undefined ? {} : { runId: options.run }),
         });
         const path = resolve(options.output ?? reportFileName(app.command, now));

package/dist/cli/messenger/report.d.ts

@@ -1,3 +1,4 @@
+import { Command } from "commander";
 import { type RunMetadata } from "../../runs/run.js";
 import type { SendEntry } from "../../sends/journal.js";
 export interface Report<Doctor extends object = Record<string, unknown>> {
@@ -29,7 +30,7 @@ export interface ReportContext {
  * journal are built that way. Two things are added: every id becomes a label, and the home
  * directory is hidden, since paths name the person's account on this machine.
  */
-export declare const buildReport: <Doctor extends object, Context extends ReportContext = Record<never, never>>({ doctor, runsDir, runId, command, sends, now, home, context, eventFields, }: {
+export declare const buildReport: <Doctor extends object, Context extends ReportContext = Record<never, never>>({ doctor, runsDir, runId, command, sends, now, home, context, eventFields, program, }: {
     doctor: Doctor;
     runsDir: string;
     runId?: string;
@@ -41,6 +42,8 @@ export declare const buildReport: <Doctor extends object, Context extends Report
     context?: Context;
     /** Retain allowlisted recorded fields, including time and severity, for an existing consumer contract. */
     eventFields?: "report" | "recorded";
+    /** The CLI's program, which tells a flag's value from a command word when the run's words are masked. */
+    program?: Command;
 }) => Report<Doctor> & Omit<Context, keyof Report>;
 /**
  * Every field of a journal line that names a chat, a message or a write. A send's `operationId` is

package/dist/cli/messenger/report.js

@@ -1,8 +1,10 @@
 import { createHash, randomBytes } from "node:crypto";
 import { join } from "node:path";
 import { CliError } from "@wirecat/cli-base";
+import { Command } from "commander";
 import { LOG_ATTRIBUTES } from "../../runs/log-attributes.js";
 import { findRun, listRuns, readEvents } from "../../runs/run.js";
+import { maskArgv } from "../../runs/run-context.js";
 const RECENT_SENDS = 20;
 /** Only these fields of a run event travel; a field added later is left out until it is named here. */
 const EVENT_FIELDS = [
@@ -21,7 +23,7 @@ const EVENT_FIELDS = [
  * journal are built that way. Two things are added: every id becomes a label, and the home
  * directory is hidden, since paths name the person's account on this machine.
  */
-export const buildReport = ({ doctor, runsDir, runId, command, sends, now = new Date(), home, context, eventFields = "report", }) => {
+export const buildReport = ({ doctor, runsDir, runId, command, sends, now = new Date(), home, context, eventFields = "report", program, }) => {
     const chosen = runId === undefined ? newestFailed(runsDir) : findRun(runsDir, runId);
     if (runId !== undefined && !chosen)
         throw new CliError("not_found", `no run ${runId} — \`${command} runs list\` names them`);
@@ -34,11 +36,18 @@ export const buildReport = ({ doctor, runsDir, runId, command, sends, now = new
             ...doctor,
             ...(account?.remembered ? { account: { ...account, remembered: label(account.remembered) } } : {}),
         },
-        run: chosen ? { metadata: chosen.metadata, events: readEvents(chosen.dir).map(eventOf(label, eventFields)) } : null,
+        run: chosen
+            ? {
+                metadata: maskedRun(chosen.metadata, program),
+                events: readEvents(chosen.dir).map(eventOf(label, eventFields)),
+            }
+            : null,
         sends: sends.slice(-RECENT_SENDS).map((entry) => labelled(entry, label)),
     };
     return JSON.parse(hideHome(JSON.stringify(report), home));
 };
+// A report leaves the machine, so it masks the typed words as `record_input: false` would.
+const maskedRun = (metadata, program = new Command()) => metadata.argv ? { ...metadata, argv: maskArgv(program, metadata.argv).argv } : metadata;
 /**
  * Every field of a journal line that names a chat, a message or a write. A send's `operationId` is
  * its `sendId`, so one left raw would undo the other's label.

package/dist/cli/program.d.ts

@@ -10,7 +10,7 @@ export interface ProgramDefinition {
     /** The CLI's own settings, for keeping a failure that happened before its command could; plain ones without. */
     configuration?: {
         permissionKey?: (path: readonly string[]) => string | null | undefined;
-        resolveSettings: (flags?: GlobalFlags, options?: ResolveOptions) => Pick<Settings, "profile" | "keepFailedRuns" | "keepRunsForDays" | "skillHint"> & Partial<Pick<Settings, "permissions" | "permissionSources" | "configPath" | "savedPermissions" | "sources">>;
+        resolveSettings: (flags?: GlobalFlags, options?: ResolveOptions) => Pick<Settings, "profile" | "keepFailedRuns" | "keepRunsForDays" | "skillHint"> & Partial<Pick<Settings, "recordInput" | "permissions" | "permissionSources" | "configPath" | "savedPermissions" | "sources">>;
     };
     configure?: (program: Command) => void;
     /** The tool's pitch and "what you can do" lines on `--help` and a bare run. */

package/dist/cli/program.js

@@ -69,7 +69,7 @@ export const createProgram = ({ app, commands, configure, firstScreen }, { out,
         .option("--full", `${found} with their whole text and every provider field`)
         .option("--dry-run", "preview parsed arguments and permissions before running the action")
         .option("--yes", "go ahead without the question an ask level puts before a write")
-        .option("--record", `keep this run — ids and timings, never ${content}`)
+        .option("--record", "keep this run, with the command as typed and secrets hidden; record_input false leaves the typed words out")
         .option("--no-record", "do not keep it, whatever the configuration says")
         .showHelpAfterError();
     for (const command of mounted)
@@ -574,7 +574,8 @@ const settleFailure = async (failure, state) => {
 /**
  * **Every failure is kept as a run** — a usage error, a configuration that will not load, a command
  * that never opens a run — unless recording was turned off. One its own run already kept is skipped.
- * Its arguments are kept masked (`maskArgv`): a value that can be a message never is.
+ * Its words are kept as `record_input` says (`maskArgv`); a configuration that did not load masks them, since it may
+ * be the one that turned recording input off.
  */
 const keepFailure = async (failure, { definition, program, rest, argv, profile, options }) => {
     if (wasSettled(failure))
@@ -599,6 +600,7 @@ const keepFailure = async (failure, { definition, program, rest, argv, profile,
             program,
             argv,
             env,
+            recordInput: settings ? settings.recordInput !== false : false,
         }),
         // Settings that did not load never accepted the word, which may be a refused name or somebody's words.
         profile: settings ? namedProfile(settings) : undefined,

package/dist/cli/settings.d.ts

@@ -97,6 +97,11 @@ export interface Settings extends AISettings {
      */
     commandTimeoutMs: number | undefined;
     record: boolean;
+    /**
+     * A run record keeps the words typed, secrets hidden; off masks every value that may be content. Optional so a CLI
+     * with settings of its own need not return it: left out, the words are kept.
+     */
+    recordInput?: boolean;
     /** A failed run is kept even unrecorded, unless recording was turned off by name. */
     keepFailedRuns: boolean;
     keepRunsForDays: number;
@@ -265,6 +270,7 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             color: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             sender_colors: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             record: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
+            record_input: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             permissions: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, (issue: v.RegexIssue<string>) => string>]>, v.PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: v.PicklistIssue) => string>, (issue: v.BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
@@ -338,6 +344,7 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             color: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             sender_colors: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             record: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
+            record_input: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             permissions: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, (issue: v.RegexIssue<string>) => string>]>, v.PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: v.PicklistIssue) => string>, (issue: v.BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;

package/dist/cli/settings.js

@@ -56,6 +56,7 @@ const SHARED_PROFILE_ENTRIES = {
     color: v.optional(flag),
     sender_colors: v.optional(flag),
     record: v.optional(flag),
+    record_input: v.optional(flag),
     keep_runs_for_days: v.optional(count),
     permissions: v.optional(permissionLevels),
     sends_per_hour: v.optional(count),
@@ -231,6 +232,7 @@ export const settingsFor = (app, extension = {}) => {
         const searchCatchUp = fromLayers("search_catch_up", false);
         const pictureSearch = fromLayers("picture_search", false);
         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);
         // Set where an agent runs unattended; the config file and `--permission` cannot undo it.
         const readOnlyLock = readOnlyLockOf(app, env);
@@ -287,6 +289,7 @@ export const settingsFor = (app, extension = {}) => {
                 ? undefined
                 : (extension.parseDuration ?? parseDuration)(timeout.value, timeout.from === TIMEOUT ? TIMEOUT : "--timeout"),
             record: record.value,
+            recordInput: recordInput.value,
             keepFailedRuns: record.value || record.from === "default",
             keepRunsForDays: keepRunsForDays.value,
             ...(readOnlyLock ? { readOnlyLock } : {}),
@@ -314,6 +317,7 @@ export const settingsFor = (app, extension = {}) => {
                 pictureSearch: pictureSearch.from,
                 searchReranker: searchReranker.from,
                 record: record.from,
+                recordInput: recordInput.from,
                 keepRunsForDays: keepRunsForDays.from,
                 sendsPerHour: sendsPerHour.from,
                 requestsPerMinute: requestsPerMinute.from,

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

@@ -79,6 +79,7 @@ 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>;
             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>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => 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>;
@@ -152,6 +153,7 @@ 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>;
             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>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => 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>;
@@ -280,6 +282,7 @@ 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>;
             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>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => 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>;
@@ -353,6 +356,7 @@ 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>;
             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>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => 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>;

package/dist/runs/error-detail.d.ts

@@ -34,6 +34,9 @@ export declare const framesOf: (error: unknown, limit?: number) => string[];
  * or a token in the path as `:id` / `:token`. The host stays — which service refused is the point.
  */
 export declare const endpointTemplate: (raw: string) => string;
+/** A phone number as people type it with its country code, and one written as digits only without the "+". */
+export declare const INTERNATIONAL_PHONE: string;
+export declare const BARE_PHONE: string;
 /**
  * An error's sentence with what could be somebody's words or a secret taken out: anything in quotes, an email, a
  * phone number, a bot token, a bearer or a long opaque string, a URL's query, the home directory. A second line of

package/dist/runs/error-detail.js

@@ -109,6 +109,9 @@ export const endpointTemplate = (raw) => {
     });
     return `${scheme}${segments.join("/")}`.slice(0, 300);
 };
+/** A phone number as people type it with its country code, and one written as digits only without the "+". */
+export const INTERNATIONAL_PHONE = /\+\d[\d\s()-]{6,}\d/.source;
+export const BARE_PHONE = /(^|[^\w-])\d{11,15}\b/.source;
 /**
  * An error's sentence with what could be somebody's words or a secret taken out: anything in quotes, an email, a
  * phone number, a bot token, a bearer or a long opaque string, a URL's query, the home directory. A second line of
@@ -119,10 +122,10 @@ export const redactText = (text) => {
     let out = home && home !== "/" ? text.split(home).join("~") : text;
     out = out
         .replace(/"[^"\n]*"|“[^”\n]*”|«[^»\n]*»/g, '"[redacted]"')
-        .replace(/\b(bearer|basic|token|key|password|secret)(\s*[:=]?\s+)\S+/gi, "$1$2[redacted]")
+        .replace(/\b(bearer|basic|token|key|password|secret)(\s*[:=]\s*|\s+)[^\s'"]+/gi, "$1$2[redacted]")
         .replace(/[\w.+-]+@[\w-]+\.[\w.-]+/g, "[email]")
-        .replace(/\+\d[\d\s()-]{6,}\d/g, "[number]")
-        .replace(/(^|[^\w-])\d{11,15}\b/g, "$1[number]")
+        .replace(new RegExp(INTERNATIONAL_PHONE, "g"), "[number]")
+        .replace(new RegExp(BARE_PHONE, "g"), "$1[number]")
         .replace(/\bbot\d+:[\w-]+/g, "bot[token]")
         .replace(/\b\d{6,}:[\w-]{20,}\b/g, "[token]")
         .replace(/(\?|&)[^\s#]*/g, "$1[redacted]")

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

@@ -1,4 +1,4 @@
-import type { Command } from "commander";
+import type { Argument, Command, Option } from "commander";
 import type { RunContext } from "./run.js";
 export declare const REDACTED = "[redacted]";
 /** Which coding agent started the process, and its session when the agent names one. Keys as written in run.json. */
@@ -17,24 +17,39 @@ export interface RunAgent {
  */
 export declare const agentOf: (env: NodeJS.ProcessEnv) => RunAgent | undefined;
 export interface MaskedArgv {
-    /** The words after the binary, every value that may be content or a secret replaced by `[redacted]`. */
+    /** The words after the binary; a secret is `[redacted]`, and with `keep` off so is every value that may be content. */
     argv: string[];
     /** The first word that names no command where one was expected. */
     unknownCommand?: string;
 }
 /**
- * The command line as typed, safe to keep. Command words, flag names and the profile stay; a value stays only when
- * its shape cannot be somebody's words — a number short of a phone's length, a duration, a date, `true`, one of the
+ * Marks an option or argument whose value a run record never keeps, whatever the owner's `record_input`; on a command,
+ * every word typed after it that is not an option.
+ */
+export declare const secretInput: <T extends Option | Argument | Command>(input: T) => T;
+/**
+ * The command line for a run record. With `keep` (the owner's `record_input`, on unless turned off) every word stays
+ * as typed except a secret: a value of an input marked `secretInput` or named for one (`--token`), a word shaped
+ * like a credential, and a phone number inside any word. With `keep` off, command words, flag names and the profile stay; a value stays only when its
+ * shape cannot be somebody's words — a number short of a phone's length, a duration, a date, `true`, one of the
  * option's declared choices — and its option or argument is not named for content (`--text`, `<phone>`). Anything
  * else, a positional after `--` or an argument no command declares, is `[redacted]`: a chat is often typed by title.
  */
-export declare const maskArgv: (program: Command, words: readonly string[]) => MaskedArgv;
-/** A run's context from the parsed program: `max messages list` and its masked words, or the word that named nothing. */
-export declare const runContextOf: ({ bin, command, program, argv, env, }: {
+export declare const maskArgv: (program: Command, words: readonly string[], { keep }?: {
+    keep?: boolean | undefined;
+}) => MaskedArgv;
+/**
+ * A run's context from the parsed program: `max messages list` and its words, or the word that named nothing. A CLI
+ * 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, }: {
     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;

package/dist/runs/run-context.js

@@ -1,4 +1,5 @@
 import { isContentKey } from "@wirecat/cli-base/standards";
+import { BARE_PHONE, INTERNATIONAL_PHONE } from "./error-detail.js";
 export const REDACTED = "[redacted]";
 /**
  * The agent is read from what each one sets in the processes it starts: Claude Code `CLAUDECODE` and
@@ -39,19 +40,60 @@ const sessionOf = (kind, env) => {
     return (variable === undefined ? undefined : env[variable]?.trim()) || undefined;
 };
 const plainWord = (word) => /^[A-Za-z][A-Za-z0-9.-]{0,39}$/.test(word);
+const secretInputs = new WeakSet();
 /**
- * The command line as typed, safe to keep. Command words, flag names and the profile stay; a value stays only when
- * its shape cannot be somebody's words — a number short of a phone's length, a duration, a date, `true`, one of the
+ * Marks an option or argument whose value a run record never keeps, whatever the owner's `record_input`; on a command,
+ * every word typed after it that is not an option.
+ */
+export const secretInput = (input) => {
+    secretInputs.add(input);
+    return input;
+};
+const SECRET_WORDS = new Set([
+    "authorization",
+    "cookie",
+    "credential",
+    "credentials",
+    "passphrase",
+    "password",
+    "secret",
+    "token",
+    "apikey",
+]);
+// Undeclared flags carry no mark, so the name is the only signal; CLIs take secrets at a prompt (WC-SECR-5) and this
+// catches the one typed anyway.
+const secretNamed = (name) => {
+    const words = name
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .split(/[\s_.-]+/)
+        .map((word) => word.toLowerCase());
+    return words.some((word, at) => SECRET_WORDS.has(word) || (word === "api" && words[at + 1] === "key"));
+};
+// A password inside a URL, or one unbroken run of 40 token characters, is a credential wherever it was typed.
+const secretShaped = (word) => /:\/\/[^/@\s:]+:[^/@\s]+@/.test(word) || /(^|[^A-Za-z0-9_-])[A-Za-z0-9_-]{40,}($|[^A-Za-z0-9_-])/.test(word);
+// Messaging CLIs promise a phone number reaches no log, so it goes even from text the record otherwise keeps.
+const withoutPhones = (word) => word.replace(new RegExp(INTERNATIONAL_PHONE, "g"), REDACTED).replace(new RegExp(BARE_PHONE, "g"), `$1${REDACTED}`);
+/**
+ * The command line for a run record. With `keep` (the owner's `record_input`, on unless turned off) every word stays
+ * as typed except a secret: a value of an input marked `secretInput` or named for one (`--token`), a word shaped
+ * like a credential, and a phone number inside any word. With `keep` off, command words, flag names and the profile stay; a value stays only when its
+ * shape cannot be somebody's words — a number short of a phone's length, a duration, a date, `true`, one of the
  * option's declared choices — and its option or argument is not named for content (`--text`, `<phone>`). Anything
  * else, a positional after `--` or an argument no command declares, is `[redacted]`: a chat is often typed by title.
  */
-export const maskArgv = (program, words) => {
+export const maskArgv = (program, words, { keep = false } = {}) => {
     const argv = [];
     let unknownCommand;
     let current = program;
     let positional = 0;
     let profileSeen = false;
     let lost = false;
+    const raw = (word) => (keep && !secretShaped(word) ? withoutPhones(word) : REDACTED);
+    const keptValue = (name, value, input) => keep
+        ? (input && secretInputs.has(input)) || secretNamed(name)
+            ? REDACTED
+            : raw(value)
+        : maskedValue(name, value, input?.argChoices);
     const optionFor = (flag) => {
         for (let at = current; at; at = at.parent) {
             const found = at.options.find((option) => option.long === flag || option.short === flag);
@@ -65,32 +107,37 @@ export const maskArgv = (program, words) => {
         if (word === "--") {
             argv.push("--");
             for (let after = at + 1; after < words.length; after++)
-                argv.push(REDACTED);
+                argv.push(raw(words[after]));
             break;
         }
         if (word.startsWith("-") && word.length > 1 && !NUMBER.test(word)) {
             const equals = word.indexOf("=");
             const flag = equals > 0 ? word.slice(0, equals) : word;
             if (!/^--?[A-Za-z0-9][A-Za-z0-9-]*$/.test(flag)) {
-                argv.push(REDACTED);
+                argv.push(raw(word));
                 continue;
             }
             const option = optionFor(flag);
             const name = option?.attributeName() ?? flag.replace(/^-+/, "");
             if (equals > 0) {
-                argv.push(`${flag}=${maskedValue(name, word.slice(equals + 1), option?.argChoices)}`);
+                argv.push(`${flag}=${keptValue(name, word.slice(equals + 1), option)}`);
                 continue;
             }
             argv.push(flag);
+            if (!option && keep && secretNamed(name) && words[at + 1] !== undefined && !words[at + 1]?.startsWith("-")) {
+                at += 1;
+                argv.push(REDACTED);
+                continue;
+            }
             if (!option || !(option.required || option.optional))
                 continue;
             const takes = (next) => next !== undefined && (option.required || !next.startsWith("-") || NUMBER.test(next));
             if (takes(words[at + 1])) {
                 at += 1;
-                argv.push(maskedValue(name, words[at], option.argChoices));
+                argv.push(keptValue(name, words[at], option));
                 while (option.variadic && words[at + 1] !== undefined && !words[at + 1].startsWith("-")) {
                     at += 1;
-                    argv.push(maskedValue(name, words[at], option.argChoices));
+                    argv.push(keptValue(name, words[at], option));
                 }
             }
             continue;
@@ -104,20 +151,20 @@ export const maskArgv = (program, words) => {
             }
             if (current === program && !profileSeen) {
                 profileSeen = true;
-                argv.push(PROFILE.test(word) ? word : REDACTED);
+                argv.push(keep ? raw(word) : PROFILE.test(word) && withoutPhones(word) === word ? word : REDACTED);
                 continue;
             }
             if (current.commands.length > 0 && current.registeredArguments.length === 0) {
                 lost = true;
                 unknownCommand = commandLike(word);
-                argv.push(unknownCommand);
+                argv.push(keep ? raw(word) : unknownCommand);
                 continue;
             }
         }
         const declared = lost ? undefined : current.registeredArguments;
         const argument = declared?.[Math.min(positional, declared.length - 1)];
         positional += 1;
-        argv.push(argument ? maskedValue(argument.name(), word, argument.argChoices) : REDACTED);
+        argv.push(secretInputs.has(current) ? REDACTED : argument ? keptValue(argument.name(), word, argument) : raw(word));
     }
     return { argv, ...(unknownCommand === undefined ? {} : { unknownCommand }) };
 };
@@ -143,9 +190,13 @@ const safeShape = (value) => (NUMBER.test(value) && !/^\d{11,}$/.test(value)) ||
     /^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/.test(value) ||
     value === "true" ||
     value === "false";
-/** A run's context from the parsed program: `max messages list` and its masked words, or the word that named nothing. */
-export const runContextOf = ({ bin, command, program, argv, env, }) => {
-    const masked = program && argv ? maskArgv(program, argv) : undefined;
+/**
+ * A run's context from the parsed program: `max messages list` and its words, or the word that named nothing. A CLI
+ * 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);
     return {
         cliCommand: command ? `${bin} ${command}` : bin,

package/dist/runs/run.d.ts

@@ -49,7 +49,7 @@ export interface RunMetadata {
     traceId?: string;
     /** The whole command with the program's name, `max messages list`; `command` stays the run's short name. */
     cliCommand?: string;
-    /** The words after the program's name, every value that may be content or a secret `[redacted]` (`maskArgv`). */
+    /** The words after the program's name, a secret `[redacted]`; with `record_input` off, any value that may be content too (`maskArgv`). */
     argv?: string[];
     /** The word that named no command, when that is why the run failed. */
     unknownCommand?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.438.0",
+  "version": "0.440.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",

package/parity.json

@@ -822,7 +822,7 @@
       "meaning": "why a task was closed, kept with it — no-reply-needed, for example"
     },
     "--record": {
-      "meaning": "keep this run under `runs` — ids and timings, never message content",
+      "meaning": "keep this run under `runs`, with the command as typed and secrets hidden; record_input false leaves the typed words out",
       "note": "max's own copy is worded differently until T6 moves the command onto the shared one (e13)"
     },
     "--remind-time": {