@wirecat/cli-core 0.566.0 → 0.568.0

package/CHANGELOG.md

@@ -7,6 +7,80 @@ shape of this file.
 
 ## Unreleased
 
+## 0.568.0 — 05.11.2026
+
+### Changed — may break callers
+
+- **`holderHasMail` is gone: `mailWaiting` checks and `advancePastSkipped` moves.** `holderHasMail` read like a
+  check but moved the holder's mark on every schedule tick. `mailWaiting(store, holder)` only reads: how many emails
+  past the holder's marks would reach it and when the oldest was stored, or `unmarked`. `advancePastSkipped(store,
+  holder)` moves the mark over the mail at its head the holder would only skip, and leaves it for the next check when
+  a sync holds the store. `ScheduleHost.newMail` now returns `MailWaiting`. A host calls `advancePastSkipped`, then
+  `mailWaiting`.
+- **A gated agent schedule waits for a batch of mail.** On its timer, `schedule agent --on-new-mail <holder>` starts
+  the agent once 10 emails wait for it or the oldest has waited 30 minutes; `--mail-wait <duration>` and
+  `--mail-batch <n>` change that per schedule, and a host's `ScheduleHost.limits` gives its config file's values
+  (`SCHEDULE_SETTINGS`, read with `scheduleLimitsOf`): flag, then config file, then default. `schedule run` by hand
+  still starts it for any mail. Its skipped answer names `why` instead of `holder`.
+- **An agent schedule stops for the day at a cost cap.** A claude run is asked for its JSON answer, so its cost
+  (`total_cost_usd`) is kept in `last.json` (`costUsd`) and summed per local day in `spend.json`; the report kept is
+  the answer's text. Once a day's runs cost `--max-cost-per-day` (default 5 US dollars, or the config file's; 0 for
+  none), no run starts until the next day; `last.json` says why under `skipped`, and `schedule list` shows the day's
+  spend and the skip.
+- **`messages acknowledge` moves only a holder the caller may move.** A run that `schedule agent --on-new-mail` started
+  gets `<PREFIX>_MAIL_HOLDER` and moves that holder's mark only; any other agent, or a run under the read-only lock,
+  is refused with `mail.holder-not-yours`; the owner moves any. A cursor past the newest stored email, or read in the
+  future, is refused with `mail.cursor-ahead`. A scheduled triage agent needs `--on-new-mail`.
+- **`review --holder` leaves out suspicious senders, and now keeps them on the mark.** Their
+  emails stay on the holder's mark and come in a later review once the sender's score is cleared, instead of being
+  passed for good. This was listed under Added in the release that brought it; it changes what an existing caller
+  reads.
+- **A mail findings citation of an email the store does not hold is `not_found`** with reason
+  `mail-findings.not-stored`, no longer `mail-findings.stale`, which told the agent to read the mailbox again. An email
+  deleted after the batch was staged still makes accepting it stale.
+- **`parseMailFindingsJson`, `parseMeetingFindingsJson` and `parseEvidenceFindingsJson` live in
+  `src/cli/findings-input.ts`;** the exports from `@wirecat/cli-core/cli` are unchanged. `findingText` and
+  `findingFields` are the checks themselves, not wrappers.
+
+### Fixed
+
+- **An accepted `new_contact` mail finding names the person.** Sync already names a sender's person from the From
+  display name, so accepting set nothing while the receipt said accepted; the owner's chosen name now replaces it.
+- **`mail review` offers at most two next steps.** It gave one `conversations show` step per cut thread, up to 50;
+  it now gives one, and names the other cut threads under `missing`.
+
+## 0.567.0 — 05.11.2026
+
+### Added
+
+- **`<tool> bot list` runs without a profile word**, as `account list` does; `<tool> <profile> bot list` still
+  works.
+- **A scheduled agent may run other CLIs the host declares** (`ScheduleHost.agentRuns`, type `AgentCli`): memo's
+  mail triage runs `mail`. Claude gets `Bash(<cli>:*)` for each; codex may write each one's state, config and cache
+  folders; every run sets `<PREFIX>_READ_ONLY=1` and `<PREFIX>_SCHEDULED` for each, whatever the schedule file says.
+  `runSchedule` takes the same list as `agentRuns`.
+- **`<PREFIX>_READ_ONLY` lets through one authority change, `rules add`, when the command is marked
+  `narrowsUnderLock`** (`LOCKED_AUTHORITY_COMMANDS`, `admittedUnderLock`). The command narrows itself under the lock;
+  every other command marked `grantsAuthority` is still refused, and MCP still needs `mcp.authority`.
+
+### Fixed
+
+- **`account list` no longer lists a bot as an account that is not signed in.** A name that only the bot side
+  uses (the file's `bot` section, a bot's own files) and that has no personal section, recorded login or session is
+  left out; `bot list` has it. A profile that is an account and a bot too says `bot: true`, a new optional field of
+  `account_profile`. `mcp serve --profiles all` serves the same account profiles. `Settings` gains the optional
+  `accountProfiles` and `botProfiles`.
+- **`config set` keeps a long id as the digits typed.** `config set --bot phone_number_id 100000000000001` was
+  parsed as a number and refused by a setting that takes text; when the parsed value is refused and the text as
+  typed passes, the text is kept, never through a JS number.
+
+### Changed — may break callers
+
+- **A write on a stale task revision fails with `conflict`, exit 15, not `configuration_error`, exit 3.** The reason
+  stays `task.stale` with the task's current `revision` in `details`; only the code and the exit number change
+  (cli-base's new `conflict`). A caller that branched on `configuration_error` for it should branch on the reason or
+  the new code. `vocabulary.stale`, `tag-review.stale` and `meeting-project.stale` keep `configuration_error` for now.
+
 ## 0.566.0 — 05.11.2026
 
 ### Changed — may break callers

package/dist/background/schedules.d.ts

@@ -19,7 +19,29 @@ export interface Schedule {
     createdAt: string;
     /** A holder whose mark gates the run: it starts only when mail is stored past that mark. */
     onNewMail?: string;
+    /** Gated on mail: start once the oldest waiting email has waited this many minutes, or `mailBatch` emails wait. */
+    mailWaitMinutes?: number;
+    mailBatch?: number;
+    /** An agent's: no run starts for the rest of the local day once its runs cost this much, in US dollars. */
+    maxCostPerDay?: number;
 }
+/** What a gated agent waits for, and what a day of its runs may cost, when neither its flags nor the config say. */
+export declare const SCHEDULE_DEFAULTS: {
+    readonly mailWaitMinutes: 30;
+    readonly mailBatch: 10;
+    readonly maxCostPerDay: 5;
+};
+/** One local day's cost of a schedule's runs, as the harness reported it (`spend.json` beside the schedule). */
+export interface DaySpend {
+    /** The local date, YYYY-MM-DD. */
+    day: string;
+    usd: number;
+}
+export declare const localDay: (at: Date) => string;
+/** What the schedule's runs cost today; nothing before its first priced run of the day. */
+export declare const spentToday: (file: string, now?: Date) => number;
+/** Another CLI a scheduled agent may run by name, as the host declares it: `memo`'s agent runs `mail`. */
+export type AgentCli = Pick<AppIdentity, "command" | "appName" | "envPrefix">;
 export interface LastRun {
     at: string;
     exitCode: number;
@@ -35,6 +57,13 @@ export interface LastRun {
     failingSince?: string;
     /** Failed runs in a row; absent once a run succeeds. */
     failures?: number;
+    /** What the run cost, as the harness reported it; absent when it reports none. */
+    costUsd?: number;
+    /** The last time the timer did not start it, and why; a run after it clears this. */
+    skipped?: {
+        at: string;
+        why: string;
+    };
 }
 /**
  * Why a failed run failed, from the error object the CLI printed last: its code and reason id. Never the
@@ -58,7 +87,10 @@ export declare const recordRun: (path: string, run: {
     traceId?: string;
     reason?: string;
     errorCode?: string;
+    costUsd?: number;
 }) => LastRun;
+/** Notes on the last run that the timer left this one out, keeping that run's result. */
+export declare const recordSkip: (file: string, why: string, at?: Date) => void;
 /**
  * One stderr line per failing background job, or nothing: `tg: scheduled digest failing since … (3 runs):
  * <reason> — tg schedule list`. A status the owner has to ask for is how a broken timer goes unnoticed.
@@ -113,11 +145,13 @@ export declare const CREDENTIALS_UNREACHABLE = "credentials.unreachable";
  * keyring, so a run that fails for that reason is tried again, a minute then up to 15 minutes apart, for up to
  * 12 hours. A schedule that repeats every few minutes is left to its next tick; a run by hand fails at once.
  */
-export declare const runSchedule: (app: AppIdentity, system: ServerSystem, env: NodeJS.ProcessEnv, file: string, { now, timer, signal, killAfterMs, untilUnlocked, wait, }?: {
+export declare const runSchedule: (app: AppIdentity, system: ServerSystem, env: NodeJS.ProcessEnv, file: string, { now, timer, signal, killAfterMs, untilUnlocked, wait, agentRuns, }?: {
     now?: () => Date;
     timer?: Timer;
     signal?: AbortSignal;
     killAfterMs?: number;
     untilUnlocked?: boolean;
     wait?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    /** The other CLIs an agent may run; each runs under its own read-only lock and knows it runs from a schedule. */
+    agentRuns?: readonly AgentCli[];
 }) => Promise<LastRun>;

package/dist/background/schedules.js

@@ -1,10 +1,54 @@
 import { spawn } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { CliError, errorCodes, writeSecurely } from "@wirecat/cli-base";
-import { readOnlyLockOf } from "../ports/app.js";
+import { mailHolderVariable, readOnlyLockOf } from "../ports/app.js";
 import { recordLogFor } from "../runs/record-log.js";
 import { childTrace } from "../runs/scope.js";
+/** What a gated agent waits for, and what a day of its runs may cost, when neither its flags nor the config say. */
+export const SCHEDULE_DEFAULTS = { mailWaitMinutes: 30, mailBatch: 10, maxCostPerDay: 5 };
+export const localDay = (at) => `${at.getFullYear()}-${String(at.getMonth() + 1).padStart(2, "0")}-${String(at.getDate()).padStart(2, "0")}`;
+const spendFile = (file) => join(file, "..", "spend.json");
+/** What the schedule's runs cost today; nothing before its first priced run of the day. */
+export const spentToday = (file, now = new Date()) => {
+    try {
+        const spend = JSON.parse(readFileSync(spendFile(file), "utf8"));
+        return spend.day === localDay(now) && typeof spend.usd === "number" ? spend.usd : 0;
+    }
+    catch {
+        return 0;
+    }
+};
+const addSpend = (folder, usd, at) => {
+    const file = join(folder, "schedule.json");
+    const spend = { day: localDay(at), usd: spentToday(file, at) + usd };
+    writeFileSync(spendFile(file), `${JSON.stringify(spend)}\n`, { mode: 0o600 });
+};
+/**
+ * Claude reports a run's cost only in its JSON answer, so a scheduled claude run asks for it; the report kept is the
+ * answer's text. Codex reports none.
+ */
+const priced = (argv) => {
+    const [program = ""] = argv;
+    const claude = /^claude(\.exe|\.cmd)?$/i.test(basename(program));
+    return claude && argv.includes("-p") && !argv.includes("--output-format")
+        ? [...argv, "--output-format", "json"]
+        : argv;
+};
+const reportOf = (stdout) => {
+    try {
+        const answer = JSON.parse(stdout.toString("utf8"));
+        if (answer?.type !== "result")
+            return { text: stdout };
+        return {
+            text: typeof answer.result === "string" ? Buffer.from(answer.result) : stdout,
+            ...(typeof answer.total_cost_usd === "number" ? { costUsd: answer.total_cost_usd } : {}),
+        };
+    }
+    catch {
+        return { text: stdout };
+    }
+};
 const REASON_ID = /^[a-z0-9][a-z0-9.-]{0,79}$/;
 /**
  * Why a failed run failed, from the error object the CLI printed last: its code and reason id. Never the
@@ -52,6 +96,14 @@ export const recordRun = (path, run) => {
     writeSecurely(path, `${JSON.stringify(last, null, 2)}\n`, 0o600);
     return last;
 };
+/** Notes on the last run that the timer left this one out, keeping that run's result. */
+export const recordSkip = (file, why, at = new Date()) => {
+    const path = join(file, "..", "last.json");
+    const before = readRun(path);
+    if (!before)
+        return;
+    writeSecurely(path, `${JSON.stringify({ ...before, skipped: { at: at.toISOString(), why } }, null, 2)}\n`, 0o600);
+};
 const shortTime = (iso) => {
     const at = new Date(iso);
     const two = (n) => String(n).padStart(2, "0");
@@ -358,7 +410,7 @@ const pause = (ms, signal) => new Promise((resolve) => {
  * keyring, so a run that fails for that reason is tried again, a minute then up to 15 minutes apart, for up to
  * 12 hours. A schedule that repeats every few minutes is left to its next tick; a run by hand fails at once.
  */
-export const runSchedule = async (app, system, env, file, { now = () => new Date(), timer, signal, killAfterMs = KILL_AFTER_MS, untilUnlocked = false, wait = pause, } = {}) => {
+export const runSchedule = async (app, system, env, file, { now = () => new Date(), timer, signal, killAfterMs = KILL_AFTER_MS, untilUnlocked = false, wait = pause, agentRuns = [], } = {}) => {
     const schedule = readSchedule(file);
     const folder = join(file, "..");
     const runs = join(folder, "runs");
@@ -366,12 +418,12 @@ export const runSchedule = async (app, system, env, file, { now = () => new Date
     const agent = schedule.kind === "agent";
     const retries = untilUnlocked && !("every" in schedule.when);
     const firstAt = now().getTime();
-    let last = await attemptSchedule(app, system, env, schedule, folder, { now, signal, killAfterMs });
+    let last = await attemptSchedule(app, system, env, schedule, folder, { now, signal, killAfterMs, agentRuns });
     for (let delay = LOCKED_FIRST_WAIT_MS; retries && lockedOut(last) && !signal?.aborted && now().getTime() - firstAt + delay <= LOCKED_GIVE_UP_MS; delay = Math.min(delay * 2, LOCKED_LONGEST_WAIT_MS)) {
         await wait(delay, signal);
         if (signal?.aborted)
             break;
-        last = await attemptSchedule(app, system, env, schedule, folder, { now, signal, killAfterMs });
+        last = await attemptSchedule(app, system, env, schedule, folder, { now, signal, killAfterMs, agentRuns });
     }
     const { exitCode, output } = last;
     const errors = agent ? output.replace(/\.md$/, ".log") : output;
@@ -399,7 +451,7 @@ export const runSchedule = async (app, system, env, file, { now = () => new Date
     return last;
 };
 /** One run of the schedule's command or agent: its output in `runs/`, its result in `last.json`. */
-const attemptSchedule = async (app, system, env, schedule, folder, { now, signal, killAfterMs }) => {
+const attemptSchedule = async (app, system, env, schedule, folder, { now, signal, killAfterMs, agentRuns, }) => {
     const runs = join(folder, "runs");
     const stamp = now()
         .toISOString()
@@ -408,15 +460,22 @@ const attemptSchedule = async (app, system, env, schedule, folder, { now, signal
     const agent = schedule.kind === "agent";
     const output = join(runs, `${stamp}.${agent ? "md" : "log"}`);
     const errors = agent ? join(runs, `${stamp}.log`) : output;
-    const [program = "", ...args] = agent ? schedule.argv : [...system.entry, ...schedule.argv];
+    const [program = "", ...args] = agent ? priced(schedule.argv) : [...system.entry, ...schedule.argv];
     const trace = childTrace();
     const childEnv = {
         ...env,
         ...schedule.environment,
         TRACEPARENT: trace.traceparent,
         [`${app.envPrefix}_SCHEDULED`]: schedule.name,
+        ...(schedule.onNewMail ? { [mailHolderVariable(app)]: schedule.onNewMail } : {}),
         // A run started under the lock stays under it, whatever the schedule file says.
         ...(agent || readOnlyLockOf(app, env) ? { [`${app.envPrefix}_READ_ONLY`]: "1" } : {}),
+        ...(agent
+            ? Object.fromEntries(agentRuns.flatMap((other) => [
+                [`${other.envPrefix}_READ_ONLY`, "1"],
+                [`${other.envPrefix}_SCHEDULED`, schedule.name],
+            ]))
+            : {}),
     };
     // The child's output is data, and an agent's is another program's: it is kept as it came. These lines say
     // only when it ran and how it ended.
@@ -424,6 +483,7 @@ const attemptSchedule = async (app, system, env, schedule, folder, { now, signal
     const facts = { schedule: schedule.name, kind: schedule.kind };
     const began = now().getTime();
     log.info({ event: "schedule.start", ...facts });
+    let costUsd;
     const exitCode = await new Promise((resolve) => {
         const child = spawn(program, args, { env: childEnv, cwd: folder, stdio: ["ignore", "pipe", "pipe"] });
         const out = [];
@@ -448,24 +508,30 @@ const attemptSchedule = async (app, system, env, schedule, folder, { now, signal
             signal?.removeEventListener("abort", stop);
             if (kill)
                 clearTimeout(kill);
-            writeFileSync(output, Buffer.concat(agent ? out : [...out, ...err]), { mode: 0o600 });
+            const report = agent ? reportOf(Buffer.concat(out)) : { text: Buffer.concat([...out, ...err]) };
+            costUsd = report.costUsd;
+            writeFileSync(output, report.text, { mode: 0o600 });
             if (agent)
                 writeFileSync(errors, Buffer.concat(err), { mode: 0o600 });
             resolve(code ?? (killedBy === "SIGKILL" ? 137 : killedBy === "SIGTERM" ? 143 : 1));
         });
     });
     const ended = now();
+    if (costUsd !== undefined)
+        addSpend(folder, costUsd, ended);
     log[exitCode === 0 ? "info" : "error"]({
         event: "schedule.exit",
         ...facts,
         exitCode,
         durationMs: ended.getTime() - began,
+        ...(costUsd === undefined ? {} : { costUsd }),
     });
     return recordRun(join(folder, "last.json"), {
         at: ended.toISOString(),
         exitCode,
         output,
         traceId: trace.traceId,
+        ...(costUsd === undefined ? {} : { costUsd }),
         ...(exitCode === 0 ? {} : failureOf(readFileSync(errors, "utf8"), exitCode)),
     });
 };

package/dist/cli/bot/command.js

@@ -119,13 +119,16 @@ const meCommand = (bot) => annotate(new Command("me"), { effects: REMOTE_READ, e
         }
     });
 });
-const listCommand = (bot, tokenVariable) => withQuery(annotate(new Command("list"), { effects: LOCAL_READ, examples: botExamples(bot, "list", "list --check") }), BOT_PROFILES_QUERY)
+const listCommand = (bot, tokenVariable) => withQuery(annotate(new Command("list"), {
+    effects: LOCAL_READ,
+    examples: [`${bot.app.command} bot list`, `${bot.app.command} bot list --check`],
+}), BOT_PROFILES_QUERY)
     .description(`every name on this machine that has a bot token; --check asks ${bot.name ?? "the messenger"} which bot each is`)
     .summary("every bot profile on this machine; --check asks which bot each is")
     .option("--check", "ask the messenger who each bot is, with its token")
     .action(async function (words) {
     const wanted = botProfileName(words);
-    const context = botContext(this, bot);
+    const context = botContext(this, bot, { needsProfile: false });
     const check = this.opts().check === true;
     if (check)
         online(context, this);

package/dist/cli/bot/context.d.ts

@@ -2,14 +2,14 @@ import type { Command } from "commander";
 import { SendJournal } from "../../sends/journal.js";
 import { type Level, type PermissionKey } from "../../sends/permissions.js";
 import { RecipientList } from "../../sends/recipients.js";
-import type { Settings } from "../settings.js";
+import type { ResolveOptions, Settings } from "../settings.js";
 import type { BotAdapter, BotChatRef, BotConnectOptions, BotMessenger } from "./port.js";
 import { ChatRegistry } from "./registry.js";
 import { BotTokenStore } from "./token.js";
 /** How the owner types this bot — `max sales bot` — so a refusal names the command that fixes it. */
 export declare const botWords: (bot: BotMessenger, profile: string) => string;
 /** What a bot command needs, resolved once: the bot's settings, its token, its lists. */
-export declare const botContext: (command: Command, bot: BotMessenger) => {
+export declare const botContext: (command: Command, bot: BotMessenger, resolving?: Pick<ResolveOptions, "needsProfile">) => {
     settings: Settings;
     renderer: import("@wirecat/cli-base").Renderer;
     format: import("@wirecat/cli-base").RenderFormat;

package/dist/cli/bot/context.js

@@ -28,8 +28,8 @@ const refuseBotPermissions = (command, bot, settings) => {
     }
 };
 /** What a bot command needs, resolved once: the bot's settings, its token, its lists. */
-export const botContext = (command, bot) => {
-    const base = baseContext(command, (flags, options) => bot.resolveSettings(flags, { ...options, kind: "bot" }));
+export const botContext = (command, bot, resolving = {}) => {
+    const base = baseContext(command, (flags, options) => bot.resolveSettings(flags, { ...options, ...resolving, kind: "bot" }));
     const { settings, env, keyring } = base;
     const profile = settings.profile;
     const files = botFiles(bot.app, profile, env);

package/dist/cli/effects.d.ts

@@ -49,6 +49,16 @@ export declare const PROPOSE_COMMANDS: readonly ["messages acknowledge", "mail f
 /** Marks a command of the `propose` tier; the lock lets it through only when its path is in `PROPOSE_COMMANDS`. */
 export declare const proposesOnly: <T extends Command>(command: T) => T;
 export declare const isProposal: (command: Command) => boolean;
+/**
+ * The authority changes `<PREFIX>_READ_ONLY` lets through, a closed list: `mail rules add`, which the owner lets the
+ * scheduled mail triage run. Such a command is marked `narrowsUnderLock` **and** has one of these paths, and under the
+ * lock it narrows itself: it only adds what the owner can list and remove, and replaces nothing. Adding a path widens
+ * what a read-only agent decides for later runs, so it needs its own review.
+ */
+export declare const LOCKED_AUTHORITY_COMMANDS: readonly ["rules add"];
+/** Marks an authority change that checks the lock itself; the lock lets it through only when its path is listed. */
+export declare const narrowsUnderLock: <T extends Command>(command: T) => T;
+export declare const admittedUnderLock: (command: Command) => boolean;
 /** 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;
 /**

package/dist/cli/effects.js

@@ -79,6 +79,25 @@ export const isProposal = (command) => {
     const path = pathOf(command).join(" ");
     return PROPOSE_COMMANDS.some((listed) => path === listed || path.endsWith(` ${listed}`));
 };
+/**
+ * The authority changes `<PREFIX>_READ_ONLY` lets through, a closed list: `mail rules add`, which the owner lets the
+ * scheduled mail triage run. Such a command is marked `narrowsUnderLock` **and** has one of these paths, and under the
+ * lock it narrows itself: it only adds what the owner can list and remove, and replaces nothing. Adding a path widens
+ * what a read-only agent decides for later runs, so it needs its own review.
+ */
+export const LOCKED_AUTHORITY_COMMANDS = ["rules add"];
+const NARROWS = new WeakSet();
+/** Marks an authority change that checks the lock itself; the lock lets it through only when its path is listed. */
+export const narrowsUnderLock = (command) => {
+    NARROWS.add(command);
+    return command;
+};
+export const admittedUnderLock = (command) => {
+    if (!NARROWS.has(command))
+        return false;
+    const path = pathOf(command).join(" ");
+    return LOCKED_AUTHORITY_COMMANDS.some((listed) => path === listed || path.endsWith(` ${listed}`));
+};
 const STORE_WRITES = new WeakSet();
 /** A local edit remains an edit even when it first fetches metadata from the messenger. */
 export const changesStore = (command) => {

package/dist/cli/index.d.ts

@@ -1,4 +1,5 @@
 export { AI_ENTRIES, AI_SETTING_KEYS, type AISettings, resolveAISettings } from "../analysis/settings.js";
+export type { AgentCli } from "../background/schedules.js";
 export { parseDuration } from "../domain/duration.js";
 export { openOf, PROFILE_PLACEHOLDER, type ProfilesFor, type RefOpen, type RefSummary, refLabel, } from "../domain/ref-summaries.js";
 export { botTemplate } from "../entities/list-results.js";
@@ -70,10 +71,11 @@ 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, fetchesOnly, fetchesOnlyAt, grantsAuthority, isLogin, isOtherServiceCall, isProposal, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, PROPOSE_COMMANDS, previewFlag, proposesOnly, REMOTE_READ, REMOTE_WRITE, reachesOtherService, readsOverMcp, readsOverMcpAt, refuseUnderReadOnly, storeChangeRefusal, writesFileOnlyWith, } from "./effects.js";
+export { admittedUnderLock, changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, fetchesOnly, fetchesOnlyAt, grantsAuthority, isLogin, isOtherServiceCall, isProposal, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, LOCKED_AUTHORITY_COMMANDS, logsInOrOut, NO_EFFECTS, narrowsUnderLock, ownerOnlyOption, PROPOSE_COMMANDS, previewFlag, proposesOnly, REMOTE_READ, REMOTE_WRITE, reachesOtherService, readsOverMcp, readsOverMcpAt, refuseUnderReadOnly, storeChangeRefusal, writesFileOnlyWith, } from "./effects.js";
 export { type CliEntry, type EntryContext, type EntryIo, openBrowser, 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";
+export { parseEvidenceFindingsJson, parseMailFindingsJson, parseMeetingFindingsJson, } from "./findings-input.js";
 export { askSetupQuestions, asksAtStart, type FirstRun, type FirstRunIo, setupAtStart, systemLanguage, } from "./first-run.js";
 export { checkGuide, checkStep, type GuideOptions, type GuideReference, type GuideStep, loadScenarios, MEMO_SCENARIOS, type Scenario, shellProblems, } from "./guide.js";
 export { type CommandHelp, commandHelp, commandHelpMarkdown, commandHelpText, exampleReport, type NextChoice, nextUsually, } from "./help/command-help.js";
@@ -86,7 +88,6 @@ export { commandPath, LIST_QUERY_GUIDE, listQuery, nativeField, nativeTermLists,
 export { MCP_HTTP_DEFAULT_PORT, type McpServerOptions, type McpServerTarget, mcpServerCommand, } from "./mcp-server-command.js";
 export { formatMeetingBatch, prepareMeetingBatch } from "./meeting-batch.js";
 export { meetingEvidenceItem, meetingPersonContextItem } from "./meeting-evidence-answer.js";
-export { parseEvidenceFindingsJson, parseMailFindingsJson, parseMeetingFindingsJson, } from "./meeting-findings-input.js";
 export { meetingPreparationAnswer } from "./meeting-preparation-answer.js";
 export { type MeetingPreparationReader, meetingPreparationInput, readMeetingPreparation, } from "./meeting-preparation-read.js";
 export { readMeetingProjectCandidates } from "./meeting-project-candidates-read.js";
@@ -119,7 +120,7 @@ export { type ProjectTextHints, projectAnswerParts, projectCutoffTime, projectEv
 export { type ProjectStatusHints, type ProjectStatusItem, projectStatusAnswer, projectStatusRow, projectStatusSchema, projectStatusText, } from "./project-status.js";
 export { STATUS_ROWS, STATUS_SIGNAL_ROWS } from "./project-status-rows.js";
 export { fieldsOf, projectFields } from "./result-fields.js";
-export type { ScheduleHost } from "./schedule/schedule-command.js";
+export { SCHEDULE_SETTINGS, type ScheduleHost, type ScheduleLimits, scheduleLimitsOf, } from "./schedule/schedule-command.js";
 export { type DeclaredSetting, type SettingRow, settingRows, withSettingDefaults } from "./setting-defaults.js";
 export { type Config, type Configuration, count, first, flag, fromFile, type GlobalFlags, NONE_NAMED, namedProfile, type ProfileKind, plain, type ResolveOptions, type Settings, type SettingsExtension, type SettingsExtensionContext, type Source, settingsFor, } from "./settings.js";
 export { type PermissionAnswer, readSetupAnswers, type SetupAnswers, setupPermissionCeiling } from "./setup-answers.js";

package/dist/cli/index.js

@@ -62,10 +62,11 @@ 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, fetchesOnly, fetchesOnlyAt, grantsAuthority, isLogin, isOtherServiceCall, isProposal, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, PROPOSE_COMMANDS, previewFlag, proposesOnly, REMOTE_READ, REMOTE_WRITE, reachesOtherService, readsOverMcp, readsOverMcpAt, refuseUnderReadOnly, storeChangeRefusal, writesFileOnlyWith, } from "./effects.js";
+export { admittedUnderLock, changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, fetchesOnly, fetchesOnlyAt, grantsAuthority, isLogin, isOtherServiceCall, isProposal, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, LOCKED_AUTHORITY_COMMANDS, logsInOrOut, NO_EFFECTS, narrowsUnderLock, ownerOnlyOption, PROPOSE_COMMANDS, previewFlag, proposesOnly, REMOTE_READ, REMOTE_WRITE, reachesOtherService, readsOverMcp, readsOverMcpAt, refuseUnderReadOnly, storeChangeRefusal, writesFileOnlyWith, } from "./effects.js";
 export { openBrowser, 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";
+export { parseEvidenceFindingsJson, parseMailFindingsJson, parseMeetingFindingsJson, } from "./findings-input.js";
 export { askSetupQuestions, asksAtStart, setupAtStart, systemLanguage, } from "./first-run.js";
 export { checkGuide, checkStep, loadScenarios, MEMO_SCENARIOS, shellProblems, } from "./guide.js";
 export { commandHelp, commandHelpMarkdown, commandHelpText, exampleReport, nextUsually, } from "./help/command-help.js";
@@ -78,7 +79,6 @@ export { commandPath, LIST_QUERY_GUIDE, listQuery, nativeField, nativeTermLists,
 export { MCP_HTTP_DEFAULT_PORT, mcpServerCommand, } from "./mcp-server-command.js";
 export { formatMeetingBatch, prepareMeetingBatch } from "./meeting-batch.js";
 export { meetingEvidenceItem, meetingPersonContextItem } from "./meeting-evidence-answer.js";
-export { parseEvidenceFindingsJson, parseMailFindingsJson, parseMeetingFindingsJson, } from "./meeting-findings-input.js";
 export { meetingPreparationAnswer } from "./meeting-preparation-answer.js";
 export { meetingPreparationInput, readMeetingPreparation, } from "./meeting-preparation-read.js";
 export { readMeetingProjectCandidates } from "./meeting-project-candidates-read.js";
@@ -109,6 +109,7 @@ export { projectAnswerParts, projectCutoffTime, projectEvidenceText, projectWind
 export { projectStatusAnswer, projectStatusRow, projectStatusSchema, projectStatusText, } from "./project-status.js";
 export { STATUS_ROWS, STATUS_SIGNAL_ROWS } from "./project-status-rows.js";
 export { fieldsOf, projectFields } from "./result-fields.js";
+export { SCHEDULE_SETTINGS, scheduleLimitsOf, } from "./schedule/schedule-command.js";
 export { settingRows, withSettingDefaults } from "./setting-defaults.js";
 export { count, first, flag, fromFile, NONE_NAMED, namedProfile, plain, settingsFor, } from "./settings.js";
 export { readSetupAnswers, setupPermissionCeiling } from "./setup-answers.js";

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

@@ -22,13 +22,18 @@ export const accountCommand = (messenger) => {
         .description("the logged-in account")
         .addCommand(withQuery(annotate(new Command("list"), { effects: REMOTE_READ, examples: [`${tool} account list`] }), ACCOUNT_PROFILES_QUERY)
         .summary("profiles on this computer and their signed-in accounts")
-        .description("every profile on this computer, and the account each is logged in as; asks the messenger nothing")
+        .description("every account profile on this computer, and the account each is logged in as; a name that is only a bot " +
+        "is left out (`bot list` has it), one that is a bot too says `bot: true`; asks the messenger nothing")
         .action(async function (words) {
         const terms = queryTerms(words, ACCOUNT_PROFILES_QUERY, "account list");
         const context = messengerContext(this, messenger, { needsProfile: false });
         const { app, provider } = messenger;
         const current = context.settings.sources.profile === NONE_NAMED ? undefined : context.settings.profile;
-        const profiles = [...new Set([...(current === undefined ? [] : [current]), ...context.settings.profilesHere])]
+        const { profilesHere, accountProfiles = profilesHere, botProfiles = [] } = context.settings;
+        const isAccount = (profile) => accountProfiles.includes(profile) || messenger.profileState?.(profile, context.env) === "signed-in";
+        const profiles = [
+            ...new Set([...(current === undefined ? [] : [current]), ...profilesHere.filter(isAccount)]),
+        ]
             .filter((profile) => terms.get("profile") === undefined || profile === terms.get("profile"))
             .filter((profile) => terms.get("current") === undefined ||
             (profile === current) === (terms.get("current")?.toLowerCase() === "true"))
@@ -48,6 +53,7 @@ export const accountCommand = (messenger) => {
                     ...(messenger.profileState
                         ? { signed_in: messenger.profileState(profile, context.env) !== "signed-out" }
                         : {}),
+                    ...(botProfiles.includes(profile) ? { bot: true } : {}),
                 });
             }
             renderAnswer(this, context, wholeList("account list", items));

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

@@ -56,7 +56,10 @@ export const servedProfiles = (self, messenger, { settings, env }, given, words,
     if (lock)
         return { set: { option: lock, profiles: () => [lock], key: `_${lock}` } };
     if (names.length === 1 && names[0] === EVERY_PROFILE) {
-        const every = () => messenger.resolveSettings(self.optsWithGlobals(), { env, needsProfile: false, readOnly: true }).profilesHere;
+        const every = () => {
+            const here = messenger.resolveSettings(self.optsWithGlobals(), { env, needsProfile: false, readOnly: true });
+            return here.accountProfiles ?? here.profilesHere;
+        };
         return { set: { option: EVERY_PROFILE, profiles: every, key: ALL_PROFILES } };
     }
     if (names.length === 0 || names.includes(EVERY_PROFILE))

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -3,9 +3,9 @@ import type { CacheDatabase } from "../../store/driver.js";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
-    error?: undefined;
     path: string;
     exists: boolean;
+    error?: undefined;
 } | {
     path: string;
     exists: boolean;

package/dist/cli/program.js

@@ -21,7 +21,7 @@ import { commandPathOf } from "./command-contract.js";
 import { entityRows } from "./compact.js";
 import { outputFor, provide } from "./context.js";
 import { refuseByCommandPermissions, refuseWriteBeforeConnecting } from "./early-refusal.js";
-import { changesAuthorityAt, changesAuthorityNow, isLogin, isStoreChange, judgedEffects, judgedTargets, storeChangeRefusal, } from "./effects.js";
+import { admittedUnderLock, changesAuthorityAt, changesAuthorityNow, isLogin, isStoreChange, judgedEffects, judgedTargets, storeChangeRefusal, } from "./effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "./envelope.js";
 import { byteCount, DEFAULT_AGENT_COOPERATIVE_MS, DEFAULT_COMMAND_MS, DEFAULT_COOPERATIVE_MS, DEFAULT_OUTPUT_BYTES, DEFAULT_SYNC_MS, execution, } from "./execution.js";
 import { setupAtStart } from "./first-run.js";
@@ -334,7 +334,7 @@ const runOnce = async (argv, definition, options) => {
         if (options.relayed && isLogin(action))
             throw new CliError("permission_error", `\`${command} ${path.join(" ")}\` logs the account in or out, which serve never runs for a client — stop ` +
                 `serve first (\`${command} ${options.relayed.profile} server stop\`), or update ${command}, which then runs it here`, { sent: false });
-        if (lock && changesAuthorityNow(action) && !flags.dryRun)
+        if (lock && changesAuthorityNow(action) && !admittedUnderLock(action) && !flags.dryRun)
             throw new CliError("permission_error", `this process is read-only (${lock}) — \`${command} ${path.join(" ")}\` changes what a later run may do; ` +
                 `run it without ${lock}`);
         if (options.agent && options.agent.authority !== true && changesAuthorityNow(action))

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

@@ -1,6 +1,9 @@
 import { Command } from "commander";
+import { type AgentCli, type Schedule } from "../../background/schedules.js";
+import { type MailWaiting } from "../../mail/marks.js";
 import { type AppIdentity } from "../../ports/app.js";
 import { type AnswerOutput } from "../envelope.js";
+import type { DeclaredSetting } from "../setting-defaults.js";
 export interface ScheduleHost {
     app: AppIdentity;
     context(command: Command, resolving?: {
@@ -10,14 +13,30 @@ export interface ScheduleHost {
         profile: string;
     };
     /**
-     * Whether mail is stored past the holder's mark (`holderHasMail`). Given, `schedule agent` takes `--on-new-mail`:
-     * the agent then runs only after a sync stored mail it has not processed.
+     * What mail waits past the holder's mark (`mailWaiting`). Given, `schedule agent` takes `--on-new-mail`: the agent
+     * then runs only once enough of it waits, or the oldest has waited long enough.
      */
-    newMail?: (command: Command, holder: string) => Promise<boolean>;
+    newMail?: (command: Command, holder: string) => Promise<MailWaiting>;
+    /** The config file's limits for agent schedules; a schedule's own flags win, `SCHEDULE_DEFAULTS` fill the rest. */
+    limits?: (command: Command) => ScheduleLimits;
+    /**
+     * Other CLIs the scheduled agent may run besides this one, each under its own `<PREFIX>_READ_ONLY`: memo's mail
+     * triage runs `mail`. Claude may run them; codex may write their state, config and cache folders.
+     */
+    agentRuns?: readonly AgentCli[];
 }
+export type ScheduleLimits = Partial<Pick<Schedule, "mailWaitMinutes" | "mailBatch" | "maxCostPerDay">>;
+/** The agent-schedule limits a host with `newMail` writes into its config file's top level (WC-CMD-30). */
+export declare const SCHEDULE_SETTINGS: readonly DeclaredSetting[];
+/** `SCHEDULE_SETTINGS` as the config file gives them; a missing or unusable value is left to the default. */
+export declare const scheduleLimitsOf: (config: {
+    schedule_mail_wait?: unknown;
+    schedule_mail_batch?: unknown;
+    schedule_max_cost_per_day?: unknown;
+}) => ScheduleLimits;
 /**
  * Runs the CLI's own commands, or an agent, later or on a timer — through systemd (Linux), launchd
  * (macOS) or Task Scheduler (Windows). Every timer runs `schedule exec <file>`; the schedule file holds
  * the rest, so what runs and with which variables is the same on all three.
  */
-export declare const scheduleCommandFor: ({ app, context: contextOf, newMail }: ScheduleHost) => Command;
+export declare const scheduleCommandFor: ({ app, context: contextOf, newMail, limits: configured, agentRuns, }: ScheduleHost) => Command;