@wirecat/cli-core 0.562.0 → 0.564.0

package/dist/cli/messenger/stats-answers.js

@@ -410,13 +410,43 @@ export const chatStatsAnswer = (stats, account, meta) => {
 };
 /** Said where the store has kept no join, leave or other chat event for the chat: a 0 would read as nobody joined. */
 export const MEMBERS_UNRECORDED = "joins and leaves are not recorded for this chat yet, so they are not counted";
-/** `stats tasks show`, CLI and MCP alike. */
-export const taskStatsAnswer = (rows, account) => itemOf({
-    open: rows.reduce((sum, row) => sum + row.open, 0),
-    rows: rows.map((row) => ({
-        chat: chatRef(account, row.group),
-        open: row.open,
-        oldest_open_at: row.oldestOpenAt?.toISOString() ?? null,
-        median_close_ms: row.medianCloseMs ?? null,
-    })),
+/** `stats tasks show`, CLI and MCP alike. A row of `--by chat` also names its chat as `chat`, as it always has. */
+export const taskStatsAnswer = (stats, account) => itemOf({
+    open: stats.open,
+    created: stats.created,
+    closed: stats.closed,
+    median_close_ms: stats.medianCloseMs ?? null,
+    mean_open_age_ms: stats.meanOpenAgeMs ?? null,
+    rows: stats.rows.map((row) => {
+        const chat = stats.by === "chat" ? chatRef(account, row.group) : undefined;
+        return {
+            ...(chat === undefined ? {} : { chat }),
+            key: chat ?? (stats.by === "project" ? `project:${row.group}` : row.group),
+            name: row.name,
+            open: row.open,
+            created: row.created,
+            closed: row.closed,
+            oldest_open_at: row.oldestOpenAt?.toISOString() ?? null,
+            median_close_ms: row.medianCloseMs ?? null,
+            mean_open_age_ms: row.meanOpenAgeMs ?? null,
+        };
+    }),
+});
+const replyFigures = (one) => ({
+    replies: one.replies,
+    median_ms: one.medianMs,
+    p90_ms: one.p90Ms,
+    mean_ms: one.meanMs,
+});
+export const responsesAnswer = (found) => itemOf({
+    who: found.who,
+    ...replyFigures(found),
+    buckets: {
+        under_5m: found.buckets.under5m,
+        under_1h: found.buckets.under1h,
+        under_1d: found.buckets.under1d,
+        over_1d: found.buckets.over1d,
+    },
+    rows: found.rows.map((row) => ({ key: row.key, ...replyFigures(row) })),
 });
+export const waitingAnswer = (found) => itemOf({ chats: found.chats, messages: found.messages, oldest_at: found.oldestAt, by_kind: found.byKind });

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

@@ -20,6 +20,7 @@ import { countersCommand } from "./counters-command.js";
 import { messagesStatsCommand } from "./messages-stats-command.js";
 import { officialStatsCommand } from "./official-stats-command.js";
 import { rankingEvidenceCommand, rankingsTopCommand } from "./rankings-command.js";
+import { replyResponsesCommand, replyWaitingCommand } from "./reply-stats-command.js";
 import { retentionCommand } from "./retention-command.js";
 import { chartAnswer, refuseJsonl } from "./stats-answers.js";
 import { tasksStatsCommand } from "./tasks-command.js";
@@ -31,6 +32,8 @@ export const statsCommand = (messenger, loadRenderer = chartRenderer) => {
         .addCommand(countersCommand(messenger))
         .addCommand(adminStatisticsCommand(messenger, "unanswered"))
         .addCommand(adminStatisticsCommand(messenger, "discussion"))
+        .addCommand(replyResponsesCommand(messenger))
+        .addCommand(replyWaitingCommand(messenger))
         .addCommand(rankingsTopCommand(messenger, "messages"))
         .addCommand(rankingEvidenceCommand(messenger, "messages")));
     stats.addCommand(new Command("contacts")
@@ -96,10 +99,12 @@ export const statsCommand = (messenger, loadRenderer = chartRenderer) => {
         "messages counters sync": '--chat "Book club" --dry-run',
         "messages counters show": '--chat "Book club" --limit 10',
         "messages discussion": 'chat:"Book club"',
+        "messages responses": "--who me --by day --timezone Europe/Madrid -- date>=30d",
         "messages evidence": '"$message" --selection "$selection" --component reactions',
         "messages show": '--chat "Book club" --by day',
         "messages top": 'chat:"Book club" --limit 10',
         "messages unanswered": 'chat:"Project room"',
+        "messages waiting": "kind:private",
         "tasks show": '--chat "Project room"',
     };
     for (const [path, args] of Object.entries(examples)) {

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

@@ -8,7 +8,8 @@ import { aheadOf, momentOf } from "../../services/moment.js";
 import { refuseAlreadyRead } from "../../services/task-analysis.js";
 import { unlistedNote } from "../../services/task-categories.js";
 import { ARRIVAL_WINDOW, applyTaskRulesToChats } from "../../services/task-rules.js";
-import { CLAIM_LEASE_MS, closedStateOf, TASK_PAIR_QUERY, TASK_QUERY, taskLinkKindOf, taskTypeOf, } from "../../services/tasks.js";
+import { TASK_STATS_BY } from "../../services/task-stats.js";
+import { CLAIM_LEASE_MS, closedStateOf, TASK_PAIR_QUERY, TASK_QUERY, TASK_STATS_QUERY, taskLinkKindOf, taskTypeOf, } from "../../services/tasks.js";
 import { PRIORITY_LABELS, priorityOption } from "../../tasks/index.js";
 import { actorOf, holderOf as holderIn } from "../author.js";
 import { environmentOf } from "../context.js";
@@ -539,32 +540,52 @@ export const tasksCommand = (messenger) => {
     });
     return tasks;
 };
+const statsByOf = (value) => {
+    if (!TASK_STATS_BY.includes(value))
+        throw new CliError("validation_error", `--by takes ${TASK_STATS_BY.join(", ")}`);
+    return value;
+};
+const minutes = (ms) => (ms === undefined ? "" : `${Math.round(ms / 60_000)} min`);
 export const tasksStatsCommand = (messenger) => {
-    return annotate(new Command("show"), { effects: LOCAL_READ, output: { entity: "task_stats" } })
-        .description("per chat: how many tasks are open, the oldest open one, the median time to close")
+    return withQuery(annotate(new Command("show"), {
+        effects: LOCAL_READ,
+        output: { entity: "task_stats" },
+        examples: [`${messenger.app.command} stats tasks show --by meeting -- created>=30d`],
+    }), TASK_STATS_QUERY)
+        .summary("count tasks by chat, meeting or project, open and closed")
+        .description("tasks per chat, meeting or project: open now, and opened and closed in the period (created: in the query), " +
+        "with the median time to close and the mean age of the open ones")
+        .option("--by <group>", "chat (default) or meeting: this account's tasks; project: the owner's project tasks, every project", statsByOf)
         .option("--chat <chat>", `only this chat; ${messenger.chatArgument}`)
         .option("--type <type>", "only this type: question, request, mention or promise", taskTypeOf)
-        .action(async function () {
+        .option("--timezone <zone>", "the IANA timezone for calendar days in the period, such as created>=today")
+        .action(async function (words) {
         const context = messengerContext(this, messenger);
-        const { chat, type } = this.opts();
+        const { by, chat, type, timezone } = this.opts();
         refuseJsonl(context.format);
-        const { rows, account } = await context.withServices(async (services) => ({
-            rows: await services.tasks.stats({
+        const query = listQuery(typedQuery(words), TASK_STATS_QUERY, "stats tasks show");
+        const { stats, account } = await context.withServices(async (services) => ({
+            stats: await services.tasks.stats({
+                ...(by === undefined ? {} : { by }),
                 ...(chat === undefined ? {} : { chat }),
-                ...(type === undefined ? {} : { type }),
+                ...(type === undefined ? {} : { kind: type }),
+                ...(query === undefined ? {} : { query }),
+                ...(timezone === undefined ? {} : { timezone }),
             }),
             account: await services.messages.reader(),
         }));
-        if (rows.length === 0)
+        if (stats.rows.length === 0)
             context.renderer.note("no tasks yet");
-        renderAnswer(this, context, taskStatsAnswer(rows, account), () => rows.length === 0
+        renderAnswer(this, context, taskStatsAnswer(stats, account), () => stats.rows.length === 0
             ? ""
-            : `${rows
-                .map(({ group, open, oldestOpenAt, medianCloseMs }) => [
-                group,
+            : `${stats.rows
+                .map(({ group, name, open, created, closed, oldestOpenAt, medianCloseMs }) => [
+                name ? `${name} (${group})` : group,
                 `${open} open`,
+                `${created} created`,
+                `${closed} closed`,
                 oldestOpenAt ? `oldest ${oldestOpenAt.toISOString().slice(0, 16).replace("T", " ")}` : "",
-                medianCloseMs === undefined ? "" : `median ${Math.round(medianCloseMs / 60_000)} min to close`,
+                medianCloseMs === undefined ? "" : `median ${minutes(medianCloseMs)} to close`,
             ]
                 .filter(Boolean)
                 .join("  "))

package/dist/cli/output-budget.d.ts

@@ -0,0 +1,26 @@
+import type { NextStep } from "@wirecat/cli-base/standards";
+import type { Command } from "commander";
+/** About a third of a 200k-token context at ~3 bytes per token (inferred, not measured). */
+export declare const SOFT_OUTPUT_BYTES: number;
+/** The same read in a form that fits the cap: one line per item, then a `--limit` scaled down to fit (WC-OUT-22). */
+export declare const tooLargeSteps: (command: Command, { maxBytes, neededBytes }: {
+    maxBytes: number;
+    neededBytes: number;
+}) => ({
+    kind: "command";
+    step: string;
+    command: string;
+    args: {
+        [x: string]: unknown;
+    };
+    line?: string | undefined;
+    why: string;
+    safe_to_auto_execute: boolean;
+} | {
+    kind: "user_action";
+    step: string;
+    why: string;
+    safe_to_auto_execute: false;
+})[];
+/** The step a large JSON answer adds: the same read, one line per item. */
+export declare const largeAnswerSteps: (command: Command) => NextStep[];

package/dist/cli/output-budget.js

@@ -0,0 +1,73 @@
+import { entityRows, GENERIC_ROW, rowShapeOf } from "./compact.js";
+import { environmentOf } from "./context.js";
+import { rootOf } from "./steps.js";
+/** About a third of a 200k-token context at ~3 bytes per token (inferred, not measured). */
+export const SOFT_OUTPUT_BYTES = 256 * 1024;
+const CARRIED = ["json", "compact", "offline", "timeout", "full", "brief", "maxOutputBytes"];
+const NOT_WITH_COMPACT = new Set(["json", "brief"]);
+const snake = (name) => name.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+const typed = (command, key) => command.getOptionValueSource(key) === "cli";
+/**
+ * The words the caller typed, as step arguments: never a default, never text an answer carried (WC-OUT-9). A
+ * `--no-x` flag and `--json=<fields>` have no form a step can carry, so a line holding one gets no step.
+ */
+const typedArgs = (command) => {
+    const root = rootOf(command);
+    if (root.getOptionValue("fields") !== undefined)
+        return undefined;
+    if (command.options.some((option) => option.negate && typed(command, option.attributeName())))
+        return undefined;
+    const positional = command.registeredArguments.flatMap((argument, index) => {
+        const value = command.processedArgs[index];
+        const word = Array.isArray(value) ? value.join(" ") : value;
+        return word === undefined || word === "" ? [] : [[argument.name(), word]];
+    });
+    const own = command.options
+        .map((option) => option.attributeName())
+        .filter((key) => typed(command, key))
+        .map((key) => [snake(key), command.getOptionValue(key)]);
+    const global = CARRIED.filter((key) => typed(root, key)).map((key) => [snake(key), root.getOptionValue(key)]);
+    return Object.fromEntries([...positional, ...own, ...global]);
+};
+const declaresRow = (command) => {
+    const { rows } = environmentOf(command);
+    return rowShapeOf(command, rows && entityRows(rows)) !== GENERIC_ROW;
+};
+const pathOf = (command) => {
+    const words = [];
+    for (let at = command; at.parent; at = at.parent)
+        words.unshift(at.name());
+    return words.join(" ");
+};
+const step = (command, id, args, why) => ({
+    kind: "command",
+    step: id,
+    command: pathOf(command),
+    args,
+    why,
+    safe_to_auto_execute: true,
+});
+const compactStep = (command, args, why) => rootOf(command).getOptionValue("compact") === true || !declaresRow(command)
+    ? []
+    : [
+        step(command, "output.compact", { ...Object.fromEntries(Object.entries(args).filter(([key]) => !NOT_WITH_COMPACT.has(key))), compact: true }, why),
+    ];
+/** The same read in a form that fits the cap: one line per item, then a `--limit` scaled down to fit (WC-OUT-22). */
+export const tooLargeSteps = (command, { maxBytes, neededBytes }) => {
+    const args = typedArgs(command);
+    if (!args)
+        return [];
+    const limit = Number(command.getOptionValue("limit"));
+    const fits = Math.floor(((limit * maxBytes) / neededBytes) * 0.9);
+    return [
+        ...compactStep(command, args, "the answer is over the output cap as JSON; one line per item keeps every ref"),
+        ...(Number.isSafeInteger(limit) && fits >= 1 && fits < limit
+            ? [step(command, "output.limit", { ...args, limit: fits }, `about ${fits} items fit under the output cap`)]
+            : []),
+    ];
+};
+/** The step a large JSON answer adds: the same read, one line per item. */
+export const largeAnswerSteps = (command) => {
+    const args = typedArgs(command);
+    return args ? compactStep(command, args, "the answer is large as JSON; one line per item keeps every ref") : [];
+};

package/dist/cli/program.js

@@ -29,6 +29,7 @@ import { installHelp } from "./help/first-screen.js";
 import { showInputFields } from "./input-fields.js";
 import { MAX_BUFFERED_INPUT, provideInputPolicy } from "./input-policy.js";
 import { checkJson, liftJson } from "./json-fields.js";
+import { tooLargeSteps } from "./output-budget.js";
 import { PreviewComplete, preview } from "./preview.js";
 import { commandWords, isProfileName, liftProfile, sampleCommand, takesProfile, valuedOptions } from "./profile.js";
 import { absolutePaths, relayTarget } from "./relay-route.js";
@@ -705,6 +706,15 @@ const commandPath = (program, rest) => {
     }
     return words.join(" ");
 };
+const budgetSteps = (program, path, failure) => {
+    const command = path ? commandAt(program, path) : undefined;
+    if (!command || !(failure instanceof CliError) || failure.details?.reason !== "output.too-large")
+        return [];
+    const { max_bytes: maxBytes, needed_bytes: neededBytes } = failure.details;
+    return typeof maxBytes === "number" && typeof neededBytes === "number"
+        ? tooLargeSteps(command, { maxBytes, neededBytes })
+        : [];
+};
 const failed = ({ app }, program, rest, error, settled, debug) => {
     const path = commandPath(program, program.args.length > 0 ? program.args : rest);
     const told = error instanceof NoProfileHere && !commandAt(program, "setup") ? error.withoutSetup(path) : error;
@@ -718,7 +728,10 @@ const failed = ({ app }, program, rest, error, settled, debug) => {
         ...(effects ? { effects } : {}),
     });
     const { next: _named, ...said } = built.error;
-    const steps = failureSteps(program, built.error);
+    const steps = failureSteps(program, {
+        ...built.error,
+        next: [...(built.error.next ?? []), ...budgetSteps(program, path, failure)],
+    });
     const object = { ...built, error: { ...said, ...(steps.length > 0 ? { next: steps } : {}) } };
     showInputFields(object, (path && commandAt(program, path)) || program);
     const command = path || app.command;

package/dist/cli/settings.d.ts

@@ -7,6 +7,7 @@ import { type Level, type PermissionKey } from "../sends/permissions.js";
 import { type HistoryLimits } from "../services/history-limits.js";
 import { type ConfigIssue } from "./config-issues.js";
 import type { CommandPermissions } from "./permission-keys.js";
+import { type DeclaredSetting } from "./setting-defaults.js";
 export declare const plain: (rule: string) => (issue: v.BaseIssue<unknown>) => string;
 export declare const count: 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>]>;
 export declare const flag: v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>;
@@ -32,6 +33,8 @@ export interface SettingsExtension<T extends object = Record<never, never>> {
     profile?: v.ObjectEntries;
     /** For the whole program only, never per profile. */
     defaults?: v.ObjectEntries;
+    /** Its own scalar settings, written into the file's `defaults` beside the shared ones (WC-CMD-30). */
+    settings?: readonly DeclaredSetting[];
     /** Profiles this messenger keeps in files of its own, beyond the config file and the remembered accounts. */
     profiles?: (env: NodeJS.ProcessEnv) => string[];
     /**
@@ -229,6 +232,8 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
         kind?: ProfileKind | undefined;
         root?: boolean;
     }) => unknown;
+    migrate: (path: string) => string[];
+    declaredSettings: DeclaredSetting[];
     allSettings: string[];
     defaultsOnlyKeys: string[];
     schema: v.StrictObjectSchema<{

package/dist/cli/settings.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { CliError, configFilePath, resolvePaths, saveConfigFile } from "@wirecat/cli-base";
 import * as v from "valibot";
-import { AI_ENTRIES, resolveAISettings } from "../analysis/settings.js";
+import { AI_DEFAULTS, 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";
@@ -14,6 +14,7 @@ import { checkConfigText, issueMessage, readConfigFile, readConfigText, savedPer
 import { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
 import { profilesHere } from "./messenger/accounts.js";
 import { usableProfileName } from "./profile.js";
+import { withSettingDefaults } from "./setting-defaults.js";
 import { permissionCeiling } from "./setup-answers.js";
 const DEFAULT_LIMIT = DEFAULT_CONFIG.defaults.limit;
 const DEFAULT_KEEP_RUNS_FOR_DAYS = DEFAULT_CONFIG.defaults.keep_runs_for_days;
@@ -107,6 +108,70 @@ const SHARED_DEFAULTS_ONLY = {
     update_check: v.optional(flag),
     skill_hint: v.optional(flag),
 };
+/**
+ * Written into the file's `defaults` at the value the code applies when the file says nothing (WC-CMD-30). Left out:
+ * objects, and settings whose absence means something no value says (`timeout_ms`, `color`, `requests_per_minute`,
+ * the embedding model), since writing any value would change what they do.
+ */
+const SHARED_SETTINGS = [
+    { key: "limit", default: DEFAULT_LIMIT, description: "how many items a list shows at once" },
+    { key: "keep_runs_for_days", default: DEFAULT_KEEP_RUNS_FOR_DAYS, description: "days a run is kept" },
+    {
+        key: "sends_per_hour",
+        default: DEFAULT_SENDS_PER_HOUR,
+        description: "the most messages an account sends in an hour; a bot has none unless its section sets one",
+    },
+    { key: "update_check", default: true, description: "check once a day for a newer version" },
+    {
+        key: "skill_hint",
+        default: true,
+        description: "tell an agent once a day that `skill install` would give it this tool's guide",
+    },
+    { key: "record", default: true, description: "keep every run in runs list; false keeps failed runs only" },
+    {
+        key: "record_input",
+        default: true,
+        description: 'keep what was typed in a run\'s command line: true, false, or "failed" for failed runs only',
+    },
+    {
+        key: "keep_successful_runs_for_days",
+        default: KEEP_SUCCESSFUL_RUNS_FOR_DAYS,
+        description: "days a successful run is kept",
+    },
+    { key: "runs_size_limit_mb", default: RUNS_SIZE_LIMIT_MB, description: "the most megabytes all runs may take" },
+    { key: "sender_colors", default: false, description: "color each sender's name in a conversation" },
+    { key: "search_catch_up", default: false, description: "prepare local search after a gaps repair" },
+    {
+        key: "history_dialog_days",
+        default: DEFAULT_HISTORY_LIMITS.dialogDays,
+        description: "days of a one-to-one chat's pushed history the store keeps",
+    },
+    {
+        key: "history_group_days",
+        default: DEFAULT_HISTORY_LIMITS.groupDays,
+        description: "days of a group's pushed history the store keeps",
+    },
+    {
+        key: "history_group_members_max",
+        default: DEFAULT_HISTORY_LIMITS.groupMembersMax,
+        description: "a group with more people than this keeps no pushed history",
+    },
+    {
+        key: "picture_search",
+        default: false,
+        description: "search and images embed read the pictures themselves, with a model on this computer",
+    },
+    {
+        key: "search_reranker",
+        default: DEFAULT_RERANK_MODEL,
+        description: "the reranker that orders search's first hits, or off",
+    },
+    {
+        key: "embedding_provider",
+        default: AI_DEFAULTS.embeddingProvider,
+        description: "local or openai: what turns text into vectors for search by meaning",
+    },
+];
 /** Where `profile` came from when none was named and the command needs none. */
 export const NONE_NAMED = "none named";
 /** A name for a command that speaks for no account; never chosen for one that does. */
@@ -174,12 +239,18 @@ export const settingsFor = (app, extension = {}) => {
     const allSettings = [...Object.keys(profileEntries), ...botOnlyKeys, ...defaultsOnlyKeys].filter((setting) => app.messenger !== false ||
         !MESSENGER_ONLY_SETTINGS.includes(setting) ||
         (app.sends === true && setting === "sends_per_hour"));
+    const readSchema = extension.schema ?? schema;
+    // An app with a schema of its own may refuse a shared key in `defaults`; writing it would break that file.
+    const declaredSettings = [...SHARED_SETTINGS, ...(extension.settings ?? [])]
+        .filter(({ key, default: value }) => allSettings.includes(key) && v.safeParse(readSchema, { defaults: { [key]: value } }).success)
+        .map((setting) => ({ ...setting, key: `defaults.${setting.key}` }));
+    // `defaults` needs no field of its own, so it is the one section created: every key then shows (RISK-2125).
+    const withDefaults = (raw, except = []) => withSettingDefaults(isScope(raw) && !Object.hasOwn(raw, "defaults") ? { ...raw, defaults: {} } : raw, declaredSettings.filter(({ key }) => !except.includes(key)));
     const PROFILE = envName(app, "PROFILE");
     const PROFILE_LOCK = envName(app, "PROFILE_LOCK");
     const TIMEOUT = envName(app, "TIMEOUT");
     const REQUESTS_PER_MINUTE = envName(app, "REQUESTS_PER_MINUTE");
     const configPathFor = ({ env = process.env, configDir }) => configFilePath(configDir ?? resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).config);
-    const readSchema = extension.schema ?? schema;
     const context = (file) => ({ file, tool: app.command });
     /** The file with every problem found; what loads is the file without the settings they name. */
     const loadConfig = (path) => {
@@ -225,7 +296,7 @@ export const settingsFor = (app, extension = {}) => {
         const configPath = configPathFor(options);
         try {
             if (!options.readOnly)
-                ensureDefaultConfig(configPath);
+                ensureDefaultConfig(configPath, withDefaults(DEFAULT_CONFIG).config);
         }
         catch (error) {
             throw new CliError("configuration_error", error instanceof Error ? error.message : String(error));
@@ -435,7 +506,7 @@ export const settingsFor = (app, extension = {}) => {
                 throw new CliError("validation_error", `${setting} has no problem to remove — name the profile, or add --defaults, to unset a setting`);
             if (!known && valueAt(raw, at) === undefined)
                 throw new CliError("validation_error", `no setting called "${setting}" — one of: ${allSettings.join(", ")}`);
-            saveConfigFile(path, withoutPath(raw, at).config);
+            saveConfigFile(path, withDefaults(withoutPath(raw, at).config, [at.join(".")]).config);
             return null;
         }
         if (!known)
@@ -456,13 +527,25 @@ export const settingsFor = (app, extension = {}) => {
         if (added)
             throw new CliError("validation_error", `${setting} cannot be "${value}": ${added.what}`);
         const checked = v.safeParse(readSchema, changed);
-        saveConfigFile(path, checked.success ? checked.output : changed);
+        saveConfigFile(path, withDefaults(checked.success ? checked.output : changed).config);
         return valueAt(checked.success ? checked.output : changed, at) ?? null;
     };
+    /** Each declared setting the file lacks, at its default, on the file as written; the keys added. */
+    const migrate = (path) => {
+        const read = readConfigFile(path);
+        if ("issue" in read)
+            throw new CliError("configuration_error", issueMessage([read.issue]));
+        const { config, added } = withDefaults(read.raw);
+        if (added.length > 0)
+            saveConfigFile(path, config);
+        return added;
+    };
     return {
         resolveSettings,
         configuredProfiles,
         changeSetting,
+        migrate,
+        declaredSettings,
         allSettings,
         defaultsOnlyKeys,
         schema,

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

@@ -8,6 +8,8 @@ export declare const appDoctorCommand: (app: import("./entry.js").AppIdentity, c
         kind?: import("./settings.js").ProfileKind | undefined;
         root?: boolean;
     }) => unknown;
+    migrate: (path: string) => string[];
+    declaredSettings: import("./setting-defaults.js").DeclaredSetting[];
     allSettings: string[];
     defaultsOnlyKeys: string[];
     schema: import("valibot").StrictObjectSchema<{
@@ -188,6 +190,8 @@ export declare const appMcpCommand: (app: import("./entry.js").AppIdentity, conf
         kind?: import("./settings.js").ProfileKind | undefined;
         root?: boolean;
     }) => unknown;
+    migrate: (path: string) => string[];
+    declaredSettings: import("./setting-defaults.js").DeclaredSetting[];
     allSettings: string[];
     defaultsOnlyKeys: string[];
     schema: import("valibot").StrictObjectSchema<{
@@ -375,6 +379,8 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
         kind?: import("./settings.js").ProfileKind | undefined;
         root?: boolean;
     }) => unknown;
+    migrate: (path: string) => string[];
+    declaredSettings: import("./setting-defaults.js").DeclaredSetting[];
     allSettings: string[];
     defaultsOnlyKeys: string[];
     schema: import("valibot").StrictObjectSchema<{
@@ -590,6 +596,8 @@ export declare const completeCommand: (messenger: import("./index.js").Messenger
         kind?: import("./settings.js").ProfileKind | undefined;
         root?: boolean;
     }) => unknown;
+    migrate: (path: string) => string[];
+    declaredSettings: import("./setting-defaults.js").DeclaredSetting[];
     allSettings: string[];
     defaultsOnlyKeys: string[];
     schema: import("valibot").StrictObjectSchema<{

package/dist/conversations/mail-text.d.ts

@@ -4,3 +4,9 @@
  * not hold stays, so a forward or a reply to an unsaved email is still found.
  */
 export declare const mailCore: (body: string, earlier: string[]) => string;
+/**
+ * What an email says itself, for a model that should not read earlier mail or the sender's signature: no quoted
+ * lines, nothing after a reply or Outlook header, no signature or mobile footer. A forwarded message is kept whole,
+ * since it is what was sent. When nothing would be left — an email that is only a quote — the body stays as it is.
+ */
+export declare const mailOwnText: (body: string) => string;

package/dist/conversations/mail-text.js

@@ -86,3 +86,76 @@ export const mailCore = (body, earlier) => {
     const kept = trimEdges(lines.filter((_, i) => !drop.has(i)));
     return withoutSignOff(withoutGreeting(kept)).join("\n").trim();
 };
+const QUOTED = /^\s*>/;
+const ATTRIBUTION_END = /(wrote|написал(\(а\)|а|и)?|escribió|a écrit|schrieb\s.+|<[^<>\s]+@[^<>\s]+>)\s*:\s*$/iu;
+/** The first line of an attribution a client wrapped in two: "On Mon, 3 Nov 2026 at 10:00, Alice Example <". */
+const ATTRIBUTION_START = /^(on|le|am|el|в)\s/iu;
+const DATED = /^(on|le|am|el|в|\d)/iu;
+const ORIGINAL = /^-{2,}\s*(original message|ursprüngliche nachricht|message d'origine|mensaje original|исходное сообщение)\s*-{2,}$/iu;
+const FROM_LINE = /^(from|von|de|от)\s?:\s*\S/iu;
+const DATE_LINE = /^(sent|date|gesendet|datum|envoyé|enviado|fecha|отправлено|дата)\s?:/iu;
+const FORWARD = /^(-{2,}\s*(forwarded message|weitergeleitete nachricht|message transféré|mensaje reenviado|пересылаемое сообщение)\s*-{2,}|begin forwarded message:)$/iu;
+const RULE = /^_{5,}$/;
+const MOBILE = /^(sent from my |von meinem .+ gesendet$|envoyé de mon |отправлено с |enviado desde mi )/iu;
+/** Where an attribution ending at `i` begins, or -1 when the line is not one. */
+const attributionAt = (lines, i) => {
+    const line = (lines[i] ?? "").trim();
+    if (!ATTRIBUTION_END.test(line))
+        return -1;
+    const prior = (lines[i - 1] ?? "").trim();
+    return prior && ATTRIBUTION_START.test(prior) && !ATTRIBUTION_START.test(line) ? i - 1 : i;
+};
+/** An Outlook header — From, then Sent or Date within the next lines — or its "Original Message" divider. */
+const outlookAt = (lines, i) => {
+    const line = (lines[i] ?? "").trim();
+    if (ORIGINAL.test(line))
+        return true;
+    return FROM_LINE.test(line) && lines.slice(i + 1, i + 4).some((next) => DATE_LINE.test(next.trim()));
+};
+const nextText = (lines, from) => lines.slice(from).find((line) => line.trim()) ?? "";
+/** The lines an email adds, in reading order: quotes dropped, and everything after a reply header cut. */
+const ownLines = (lines) => {
+    const kept = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (QUOTED.test(line))
+            continue;
+        if (outlookAt(lines, i)) {
+            const last = kept.findLastIndex((one) => one.trim());
+            return last !== -1 && RULE.test((kept[last] ?? "").trim()) ? kept.slice(0, last) : kept;
+        }
+        const start = attributionAt(lines, i);
+        if (start === -1) {
+            kept.push(line);
+            continue;
+        }
+        if (start < i)
+            kept.pop();
+        if (QUOTED.test(nextText(lines, i + 1)))
+            continue;
+        // Without quote marks only a dated header is one: "Here is what Bob wrote:" is not.
+        const header = lines
+            .slice(start, i + 1)
+            .join(" ")
+            .trim();
+        if (/\d/.test(header) && (header.includes("@") || DATED.test(header)) && header.length <= 300)
+            return kept;
+        if (start < i)
+            kept.push(lines[start] ?? "");
+        kept.push(line);
+    }
+    return kept;
+};
+/**
+ * What an email says itself, for a model that should not read earlier mail or the sender's signature: no quoted
+ * lines, nothing after a reply or Outlook header, no signature or mobile footer. A forwarded message is kept whole,
+ * since it is what was sent. When nothing would be left — an email that is only a quote — the body stays as it is.
+ */
+export const mailOwnText = (body) => {
+    const lines = body.replace(/\r\n?/g, "\n").split("\n");
+    const forward = lines.findIndex((line) => FORWARD.test(line.trim()));
+    const head = forward === -1 ? lines : lines.slice(0, forward);
+    const own = withoutSignOff(trimEdges(ownLines(head).filter((line) => !MOBILE.test(line.trim()))));
+    const text = [...own, ...(forward === -1 ? [] : ["", ...lines.slice(forward)])].join("\n").trim();
+    return text || body.trim();
+};

package/dist/domain/admin-statistics.d.ts

@@ -75,4 +75,9 @@ export interface AdminCalculated {
     graph: ReturnType<typeof rankReplyGraph>["quality"];
 }
 export declare const adminEntityKey: (row: Pick<AdminRow, "account" | "id">) => string;
+/** Median and nearest-rank p90 of reply delays, the numbers every response-time answer reports. */
+export declare const delayStats: (delays: number[]) => {
+    medianMilliseconds: number | null;
+    p90Milliseconds: number | null;
+};
 export declare const calculateAdminStatistics: (nodes: AdminNode[], stays: AdminStay[], options: AdminOptions, inspect: () => void) => AdminCalculated;

package/dist/domain/admin-statistics.js

@@ -6,7 +6,8 @@ import { rankingQuestion } from "./rankings-options.js";
 export const adminEntityKey = (row) => JSON.stringify([row.account.provider, row.account.account, row.id]);
 const personKey = (node) => JSON.stringify([node.account.provider, node.account.account, node.sender]);
 const locator = (node) => formatLocator({ ...node.account, chat: node.chatId, message: node.id });
-const stats = (delays) => {
+/** Median and nearest-rank p90 of reply delays, the numbers every response-time answer reports. */
+export const delayStats = (delays) => {
     const sorted = delays.toSorted((a, b) => a - b);
     const middle = Math.floor(sorted.length / 2);
     return {
@@ -103,7 +104,7 @@ export const calculateAdminStatistics = (nodes, stays, options, inspect) => {
                 account: { provider: person.provider, account: person.account },
                 questions: eligible.filter((node) => node.account.provider === person.provider && node.account.account === person.account).length,
                 answered: rows.length,
-                ...stats(rows.map((row) => row.contribution)),
+                ...delayStats(rows.map((row) => row.contribution)),
                 status: "observed",
             }, rows);
         }
@@ -154,7 +155,7 @@ export const calculateAdminStatistics = (nodes, stays, options, inspect) => {
                 pending: end > options.cutoff,
                 questions: held.length,
                 answered: delays.length,
-                ...stats(delays),
+                ...delayStats(delays),
                 status: "partial",
             }, contributions);
         }

package/dist/domain/calendar.d.ts

@@ -1 +1,3 @@
 export declare const calendarKey: (zone: string, by: "day" | "hour") => (time: number) => string;
+/** The Monday that starts the week of a `YYYY-MM-DD` day. */
+export declare const weekKey: (day: string) => string;