@wirecat/cli-core 0.566.0 → 0.567.0

package/CHANGELOG.md

@@ -5,7 +5,37 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
-## Unreleased
+## 0.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
 

package/dist/background/schedules.d.ts

@@ -20,6 +20,8 @@ export interface Schedule {
     /** A holder whose mark gates the run: it starts only when mail is stored past that mark. */
     onNewMail?: string;
 }
+/** 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;
@@ -113,11 +115,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

@@ -358,7 +358,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 +366,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 +399,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()
@@ -417,6 +417,12 @@ const attemptSchedule = async (app, system, env, schedule, folder, { now, signal
         [`${app.envPrefix}_SCHEDULED`]: schedule.name,
         // 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.

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,7 +71,7 @@ export { sharedCommandTemplate } from "./contract-templates.js";
 export { type Closeable, withDeadline } from "./deadline.js";
 export { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
 export { DISCOVERY_DESCRIPTIONS } from "./discovery-descriptions.js";
-export { changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, 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";

package/dist/cli/index.js

@@ -62,7 +62,7 @@ export { sharedCommandTemplate } from "./contract-templates.js";
 export { withDeadline } from "./deadline.js";
 export { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
 export { DISCOVERY_DESCRIPTIONS } from "./discovery-descriptions.js";
-export { changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, 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";

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,4 +1,5 @@
 import { Command } from "commander";
+import { type AgentCli } from "../../background/schedules.js";
 import { type AppIdentity } from "../../ports/app.js";
 import { type AnswerOutput } from "../envelope.js";
 export interface ScheduleHost {
@@ -14,10 +15,15 @@ export interface ScheduleHost {
      * the agent then runs only after a sync stored mail it has not processed.
      */
     newMail?: (command: Command, holder: string) => Promise<boolean>;
+    /**
+     * 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[];
 }
 /**
  * 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, agentRuns }: ScheduleHost) => Command;

package/dist/cli/schedule/schedule-command.js

@@ -81,7 +81,8 @@ const promptExample = (app) => app.messenger === false
  * (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 const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
+export const scheduleCommandFor = ({ app, context: contextOf, newMail, agentRuns = [] }) => {
+    const agentClis = [app, ...agentRuns];
     const command = new Command("schedule").description(`run a ${app.command} command or an agent later or on a timer (systemd, launchd, Task Scheduler); an agent cannot send`);
     const prepare = (self, resolving = {}) => {
         const context = contextOf(self, resolving);
@@ -154,7 +155,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
             `${app.command} personal schedule agent triage codex "list what needs an answer today" --every 2h --max-cost 1`,
         ],
     }))
-        .description(`start an agent (claude or codex) with a prompt on a timer; it runs with ${app.envPrefix}_READ_ONLY=1, so it reads and drafts and cannot send — its answer is kept and you are notified`)
+        .description(`start an agent (claude or codex) with a prompt on a timer; it runs with ${agentClis.map((one) => `${one.envPrefix}_READ_ONLY=1`).join(" and ")}, so it reads and drafts and cannot send — its answer is kept and you are notified`)
         .argument("<name>", "lowercase letters, digits and dashes")
         .addArgument(new Argument("<harness>", "the agent to start").choices(HARNESSES))
         .argument("<prompt>", `what to do, e.g. "${promptExample(app)}"`)
@@ -166,7 +167,10 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
         const program = findProgram(harness, context.env, system.platform);
         if (!program)
             throw new CliError("not_found", `${harness} is not on PATH`);
-        const paths = resolvePaths({ appName: app.appName, prefix: app.envPrefix, env: context.env });
+        const folders = agentClis.flatMap((one) => {
+            const paths = resolvePaths({ appName: one.appName, prefix: one.envPrefix, env: context.env });
+            return [paths.state, paths.config, paths.cache];
+        });
         const argv = harness === "claude"
             ? [
                 program,
@@ -176,7 +180,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
                 "--permission-mode",
                 "dontAsk",
                 "--allowedTools",
-                `Bash(${app.command}:*)`,
+                ...agentClis.map((one) => `Bash(${one.command}:*)`),
                 "--no-session-persistence",
                 ...(options.maxCost ? ["--max-budget-usd", String(options.maxCost)] : []),
             ]
@@ -187,13 +191,10 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
                 "--ephemeral",
                 "--sandbox",
                 "workspace-write",
-                // The CLI reaches the messenger and writes its store and state, and nothing else.
+                // The CLIs reach their provider and write the store and their own state, and nothing else.
                 "-c",
                 "sandbox_workspace_write.network_access=true",
-                ...[dirname(storePath(context.env)), paths.state, paths.config, paths.cache].flatMap((dir) => [
-                    "--add-dir",
-                    dir,
-                ]),
+                ...[dirname(storePath(context.env)), ...folders].flatMap((dir) => ["--add-dir", dir]),
                 prompt,
             ];
         await save({
@@ -263,6 +264,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
             return say({ name, skipped: true, holder }, [`${name}: skipped — no mail stored past ${holder}'s mark`]);
         const last = await untilChildEnds(this, (signal) => runSchedule(app, system, context.env, scheduleFile(state, scheduleName(name)), {
             timer: timer(),
+            agentRuns,
             ...(signal ? { signal } : {}),
         }));
         say(snakeKeys({ name, ...last }), [`${name}: exit ${last.exitCode} — ${last.output}`]);
@@ -297,6 +299,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
             return;
         const last = await untilChildEnds(this, (signal) => runSchedule(app, system, context.env, file, {
             timer: timer(),
+            agentRuns,
             untilUnlocked: true,
             ...(signal ? { signal } : {}),
         }));

package/dist/cli/settings.d.ts

@@ -156,8 +156,16 @@ export interface Settings extends AISettings {
     configFound: boolean;
     /** Profiles the configuration file names, whether or not anyone has logged in to them. */
     configuredProfiles: string[];
-    /** Every profile on this computer — what `account list` shows and a missing profile's error lists. */
+    /** Every profile on this computer, bots included — what a missing profile's error lists. */
     profilesHere: string[];
+    /**
+     * The profiles here that are an account, not only a bot — what `account list` shows. A name only the file's bot
+     * section names, with no personal section, recorded login or messenger profile of its own, is a bot. Absent for an
+     * app that builds `Settings` itself; `profilesHere` stands in.
+     */
+    accountProfiles?: string[];
+    /** Every name with a bot: the file's bot section, or a bot's own files. `account list` marks these. */
+    botProfiles?: string[];
     /** Where each value came from — `config show` prints it. */
     sources: Record<string, Source>;
     /** This profile's entries and the shared defaults, for an adapter resolving its own fields with `first`. */

package/dist/cli/settings.js

@@ -10,9 +10,10 @@ import { assertOverridesTighten, CEILING_KEY, COMMAND_PATH_KEY, LEVELS, layerPer
 import { DEFAULT_HISTORY_LIMITS, HISTORY_MAX_DAYS } from "../services/history-limits.js";
 import { storePath } from "../store/path.js";
 import { sharedConfigPath } from "../store/shared-config.js";
+import { registryProfiles } from "./bot/registry.js";
 import { checkConfigText, issueMessage, readConfigFile, readConfigText, savedPermissionKeys, schemaIssues, settingPathOf, withoutPath, } from "./config-issues.js";
 import { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
-import { profilesHere } from "./messenger/accounts.js";
+import { profilesHere, profilesWithAccounts } from "./messenger/accounts.js";
 import { usableProfileName } from "./profile.js";
 import { withSettingDefaults } from "./setting-defaults.js";
 import { permissionCeiling } from "./setup-answers.js";
@@ -298,6 +299,16 @@ export const settingsFor = (app, extension = {}) => {
         throw new CliError("validation_error", `name a profile: \`${app.command} <profile> …\` — profiles here: ${here.join(", ")} (or set ${PROFILE})`, { profiles: here });
     };
     const profilesOf = (config, env) => profilesHere(app, [...namedProfiles(config), ...(extension.profiles?.(env) ?? [])], env);
+    const botsOf = (config, env) => [...new Set([...Object.keys(config.bot?.profiles ?? {}), ...registryProfiles(app, env)])].sort();
+    // The shared `profiles` section is no sign of an account: a bot's owner may set something there for both sides.
+    const accountsOf = (config, env, bots) => {
+        const personal = new Set([
+            ...Object.keys(config.personal?.profiles ?? {}),
+            ...profilesWithAccounts(app, env),
+            ...(extension.profiles?.(env) ?? []),
+        ]);
+        return profilesOf(config, env).filter((name) => !bots.includes(name) || personal.has(name));
+    };
     const resolveSettings = (flags = {}, options = {}) => {
         const env = options.env ?? process.env;
         const configPath = configPathFor(options);
@@ -322,6 +333,7 @@ export const settingsFor = (app, extension = {}) => {
             ? unnamed(config, env, options.needsProfile !== false)
             : { value: named.value, from: named.from }, lock);
         const kind = options.kind ?? "personal";
+        const bots = botsOf(config, env);
         const name = usableProfileName(profile.value);
         const configured = config.profiles[name] ?? {};
         const shared = config.defaults ?? {};
@@ -429,6 +441,8 @@ export const settingsFor = (app, extension = {}) => {
             configFound: existsSync(configPath),
             configuredProfiles: namedProfiles(config),
             profilesHere: profilesOf(config, env),
+            accountProfiles: accountsOf(config, env, bots),
+            botProfiles: bots,
             sources: {
                 ...ai.sources,
                 profile: profile.from,
@@ -527,10 +541,22 @@ export const settingsFor = (app, extension = {}) => {
         if (kind !== "bot" && botOnlyKeys.includes(setting)) {
             throw new CliError("validation_error", `${setting} is a bot's setting — add --bot`);
         }
-        const changed = structuredClone(raw);
-        setAt(changed, at, level === undefined ? parseValue(value) : value.trim());
         const had = new Set(before.map((issue) => issue.at.join(".")));
-        const added = schemaIssues(changed, readSchema, context(path)).find((issue) => !had.has(issue.at.join(".")) || issue.at.join(".") === at.join("."));
+        const tried = (typed) => {
+            const changed = structuredClone(raw);
+            setAt(changed, at, typed);
+            const added = schemaIssues(changed, readSchema, context(path)).find((issue) => !had.has(issue.at.join(".")) || issue.at.join(".") === at.join("."));
+            return { changed, added };
+        };
+        const parsed = level === undefined ? parseValue(value) : value.trim();
+        let { changed, added } = tried(parsed);
+        // `phone_number_id 100000000000001` parses as a number; a setting that takes text keeps the digits as typed,
+        // never through a number, which rounds any id past 2^53.
+        if (added && typeof parsed !== "string") {
+            const asText = tried(value.trim());
+            if (!asText.added)
+                ({ changed, added } = asText);
+        }
         if (added)
             throw new CliError("validation_error", `${setting} cannot be "${value}": ${added.what}`);
         const checked = v.safeParse(readSchema, changed);

package/dist/entities/account-profile.d.ts

@@ -6,4 +6,6 @@ export declare const accountProfile: v.StrictObjectSchema<{
     readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     /** False for a profile with no session on this computer; absent when the messenger does not say. */
     readonly signed_in: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    /** True when the same name is a bot profile too (`<tool> <profile> bot …`); absent otherwise. */
+    readonly bot: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
 }, undefined>;

package/dist/entities/account-profile.js

@@ -7,4 +7,6 @@ export const accountProfile = v.strictObject({
     name: v.nullable(text),
     /** False for a profile with no session on this computer; absent when the messenger does not say. */
     signed_in: v.optional(v.boolean()),
+    /** True when the same name is a bot profile too (`<tool> <profile> bot …`); absent otherwise. */
+    bot: v.optional(v.literal(true)),
 });

package/dist/entities/index.d.ts

@@ -3885,6 +3885,7 @@ export declare const ENTITIES: {
         readonly account: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
         readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly signed_in: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly bot: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
     }, undefined>;
     readonly organization: v.StrictObjectSchema<{
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

package/dist/errors/reasons.js

@@ -235,7 +235,7 @@ const OTHERS = [
     validation("task.category-unknown", "the category is not in the task category list"),
     validation("task.claimed", "someone else holds the task"),
     validation("task.closed", "the task is already closed"),
-    ["task.stale", "configuration_error", "the task changed since it was read; read it again"],
+    ["task.stale", "conflict", "the task changed since it was read; read it again"],
     validation("task.column", "the task beside which it moves is in another column than the status asked for"),
     validation("task.dependency-cycle", "the task would depend on itself"),
     validation("task.is-subtask", "a subtask moves to another project alone only when it is detached from its parent in the same write"),

package/dist/store/sqlite/work-tasks.js

@@ -68,7 +68,7 @@ const timesAsIso = (changes) => Object.fromEntries(Object.entries(changes).map((
 export const checkRevision = (row, expected) => {
     if (expected === undefined || Number(row.revision) === expected)
         return;
-    throw new CliError("configuration_error", `task ${String(row.key)} changed since revision ${expected}; it is at ${String(row.revision)}: read it again`, { reason: "task.stale", revision: Number(row.revision) });
+    throw new CliError("conflict", `task ${String(row.key)} changed since revision ${expected}; it is at ${String(row.revision)}: read it again`, { reason: "task.stale", revision: Number(row.revision) });
 };
 export const workTaskOperationsOver = (context) => {
     const { database, now } = context;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.566.0",
+  "version": "0.567.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",