@wirecat/cli-core 0.565.0 → 0.567.0

package/CHANGELOG.md

@@ -5,7 +5,65 @@ 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
+
+### Changed — may break callers
+
+- **cli-core now needs `@wirecat/cli-base` 0.76.0 or later** (peer range `>=0.76.0 <0.78.0`), which holds
+  `loadConstants`.
+- **`appDoctorCommand`'s `oauthClient` returns `oauthClientReport`'s shape, `{ client, source, reason? }`**, and a
+  throw there is reported as `{ client: null, source: null, reason }` (was `error`). drive's and gcal's callers
+  change with their bump.
+
+### Added
+
+- **`@wirecat/cli-core/constants`: WireCat's sign-in apps ship in cli-core's `constants.json`.** `constants()` reads
+  cli-base's, cli-core's and the tool's `constants.json` once per process, merged, validated and frozen; a tool
+  passes its own layer and a schema built on `constantsSchema`. It holds WireCat's Google Desktop app
+  (`google.app.client_id`, `client_secret`) and Microsoft client id (`microsoft.app.client_id`), which drive and mail
+  kept in source and gcal expected from a file CI wrote. `googleApp({ env, prefix, clientFile, clientId,
+  configClientId })` and `microsoftApp(…)` pick the app in WC-SECR-25's order: `--client-file` or `--client-id`
+  (`flag`), `<PREFIX>_<PROVIDER>_CLIENT_ID` (`env`), the account's `<provider>.client_id` (`config`), WireCat's app
+  (`constants`); a `_SECRET` with no id is a `configuration_error`, reason `sign-in.secret-without-id`. `oauthApp`
+  does the same for a provider whose app is in a tool's layer, such as Zoom, and returns nothing when there is none.
+  `oauthClientReport(app, reason?)` is `doctor`'s `oauth_client`: `{ client: "wirecat" | "own" | null, source }`.
+  See [Constants](docs/dev/CONSTANTS.md).
+- **A sign-in entry records where its app came from** (`clientSource` in the standard and drive entries, read back
+  as `client.source`), so `doctor` reports the app the account signed in with. The standard entry also keeps
+  WireCat's public secret, so a refresh still works after a release ships another default app; an owner's own
+  secret is still never written.
 
 ## 0.565.0 — 05.11.2026
 

package/constants.json

@@ -0,0 +1,13 @@
+{
+  "google": {
+    "app": {
+      "client_id": "_WAlQe_1Jamd97lrbGU1kcXOJ8TWiJSbdfyTOEEF6IqtlI9-L2lr8iTW7MmAqUn7XMpK1OXeRZNLCFlYULdV3C5HGV28xT2CL0QFEI3FC3oHZp-ak5TX9g",
+      "client_secret": "X6afcHNZ_v0d_N6-jCWHFQSeT2O-saKLY8_WY_W5aIlswI6q2EZ6GtF3IFhy6WjIHUzB"
+    }
+  },
+  "microsoft": {
+    "app": {
+      "client_id": "f7f05d3a-b948-4d50-b3ce-59c816ce69e9"
+    }
+  }
+}

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/app-doctor-command.d.ts

@@ -1,14 +1,14 @@
 import { Command } from "commander";
+import type { OAuthClientReport } from "../constants/index.js";
 import { type AppIdentity } from "../ports/app.js";
 import type { Configuration } from "./settings.js";
 export interface AppDoctorOptions {
     /**
-     * Which OAuth client the CLI signs in with — WireCat's or one of the owner's own — read from the environment and
-     * files only. A throw is reported as its message.
+     * The OAuth app a new sign-in would use (WC-SECR-25), read from the environment and files only, usually
+     * `oauthClientReport` of the tool's `googleApp`/`oauthApp`. A throw is reported as a null client with its message as
+     * the reason.
      */
-    oauthClient?: (env: NodeJS.ProcessEnv) => {
-        client: "wirecat" | "own";
-    };
+    oauthClient?: (env: NodeJS.ProcessEnv) => OAuthClientReport;
     /** The npm package, so `--online` can say whether a newer version is published; without it that check is left out. */
     packageName?: string;
     /**
@@ -48,10 +48,7 @@ export declare const appDoctorReport: (app: AppIdentity, configuration: Configur
             path: string;
             exists: boolean;
         };
-        oauth_client?: {
-            client: "wirecat" | "own" | null;
-            error?: string;
-        } | undefined;
+        oauth_client?: OAuthClientReport | undefined;
         read_only: string | null;
         profile_lock: string | null;
         config: {
@@ -90,10 +87,7 @@ export declare const appDoctorReport: (app: AppIdentity, configuration: Configur
             path: string;
             exists: boolean;
         };
-        oauth_client?: {
-            client: "wirecat" | "own" | null;
-            error?: string;
-        } | undefined;
+        oauth_client?: OAuthClientReport | undefined;
         read_only: string | null;
         profile_lock: string | null;
         config: {

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

@@ -85,7 +85,7 @@ export const appDoctorReport = (app, configuration, env, command, options = {})
             oauth = options.oauthClient(env);
         }
         catch (error) {
-            oauth = { client: null, error: failure(error) };
+            oauth = { client: null, source: null, reason: failure(error) };
         }
     const common = {
         version: app.version,

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/constants/index.d.ts

@@ -0,0 +1,83 @@
+import * as v from "valibot";
+import type { AppSource, OAuthClient } from "../oauth/provider.js";
+/** cli-core's layer, read after cli-base's and before the tool's. */
+export declare const CORE_CONSTANTS: import("url").URL;
+/** What cli-base's and cli-core's layers hold; a tool extends it with `v.object({ ...constantsSchema.entries, … })`. */
+export declare const constantsSchema: v.ObjectSchema<{
+    readonly google: v.ObjectSchema<{
+        readonly app: v.ObjectSchema<{
+            readonly client_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, string>]>;
+            readonly client_secret: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TransformAction<string, string>]>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly microsoft: v.ObjectSchema<{
+        readonly app: v.ObjectSchema<{
+            readonly client_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>;
+export type Constants = v.InferOutput<typeof constantsSchema>;
+/**
+ * The packaged constants, base → core → the tool's `constants.json` when given, read once per process for each tool
+ * layer. A tool with constants of its own passes its layer and a schema built on `constantsSchema`; the first call for
+ * a layer decides its schema.
+ */
+export declare const constants: <TSchema extends v.GenericSchema<unknown, Constants> = typeof constantsSchema>(toolLayer?: URL, schema?: TSchema) => v.InferOutput<TSchema>;
+export interface AppOptions {
+    env: NodeJS.ProcessEnv;
+    /** The tool's environment prefix: `GCAL` with provider `google` reads `GCAL_GOOGLE_CLIENT_ID` and `_SECRET`. */
+    prefix: string;
+    /** `--client-id`. A secret for it comes from `<PREFIX>_<PROVIDER>_CLIENT_SECRET`. */
+    clientId?: string | undefined;
+    /** The account's config key `<provider>.client_id`. A config file never holds the secret: it comes from the env. */
+    configClientId?: string | undefined;
+}
+export interface OAuthAppOptions extends AppOptions {
+    /** `google`, `microsoft`, `zoom`: names the env variables, upper-cased. */
+    provider: string;
+    /** WireCat's app from the constants; an empty or missing id means WireCat has none for this provider. */
+    wirecat?: {
+        client_id?: string | undefined;
+        client_secret?: string | undefined;
+    } | undefined;
+}
+export interface OAuthApp {
+    client: OAuthClient & {
+        source: AppSource;
+    };
+    source: AppSource;
+}
+/**
+ * The app a sign-in uses, first match wins (WC-SECR-25): `--client-id`, `<PREFIX>_<PROVIDER>_CLIENT_ID`, the account's
+ * `<provider>.client_id`, WireCat's app. A secret without any of the first three ids is a `configuration_error`.
+ * Undefined when nothing names an app and WireCat has none.
+ */
+export declare const oauthApp: (options: OAuthAppOptions) => OAuthApp | undefined;
+export interface GoogleAppOptions extends AppOptions {
+    /** The owner's Desktop client JSON, `--client-file`; it must be private to the owner. */
+    clientFile?: string | undefined;
+    platform?: NodeJS.Platform;
+    /** The tool's own constants, when its layer overrides the app. */
+    constants?: Constants;
+}
+/**
+ * The Google Desktop app a sign-in uses: `--client-file`, then `oauthApp`'s order. Google treats a Desktop app's
+ * secret as public (https://developers.google.com/identity/protocols/oauth2/native-app), so WireCat's ships, obscured,
+ * in cli-core's constants.
+ */
+export declare const googleApp: (options: GoogleAppOptions) => OAuthApp;
+/** WireCat's Microsoft app is a public client: it has an id and no secret. */
+export declare const microsoftApp: (options: AppOptions & {
+    constants?: Constants;
+}) => OAuthApp;
+export interface OAuthClientReport {
+    client: "wirecat" | "own" | null;
+    source: AppSource | null;
+    /** Why there is no app, when `client` is null. */
+    reason?: string;
+}
+/** `doctor`'s `oauth_client` for one provider: the app a new sign-in would use; doctor reads no keyring. */
+export declare const oauthClientReport: (app: {
+    source?: AppSource | undefined;
+} | undefined, reason?: string) => OAuthClientReport;
+export type { AppSource };

package/dist/constants/index.js

@@ -0,0 +1,77 @@
+import { BASE_CONSTANTS, baseConstantsSchema, CliError, loadConstants } from "@wirecat/cli-base";
+import * as v from "valibot";
+import { readClientFile } from "../oauth/client-file.js";
+import { reveal } from "./obscure.js";
+/** cli-core's layer, read after cli-base's and before the tool's. */
+export const CORE_CONSTANTS = new URL("../../constants.json", import.meta.url);
+/** What cli-base's and cli-core's layers hold; a tool extends it with `v.object({ ...constantsSchema.entries, … })`. */
+export const constantsSchema = v.object({
+    ...baseConstantsSchema.entries,
+    google: v.object({
+        app: v.object({
+            client_id: v.pipe(v.string(), v.nonEmpty(), v.transform(reveal)),
+            client_secret: v.optional(v.pipe(v.string(), v.transform(reveal))),
+        }),
+    }),
+    microsoft: v.object({ app: v.object({ client_id: v.pipe(v.string(), v.nonEmpty()) }) }),
+});
+const loaded = new Map();
+/**
+ * The packaged constants, base → core → the tool's `constants.json` when given, read once per process for each tool
+ * layer. A tool with constants of its own passes its layer and a schema built on `constantsSchema`; the first call for
+ * a layer decides its schema.
+ */
+export const constants = (toolLayer, schema) => {
+    const key = toolLayer?.href ?? "";
+    if (!loaded.has(key)) {
+        const layers = toolLayer ? [BASE_CONSTANTS, CORE_CONSTANTS, toolLayer] : [BASE_CONSTANTS, CORE_CONSTANTS];
+        loaded.set(key, loadConstants(layers, schema ?? constantsSchema));
+    }
+    return loaded.get(key);
+};
+/**
+ * The app a sign-in uses, first match wins (WC-SECR-25): `--client-id`, `<PREFIX>_<PROVIDER>_CLIENT_ID`, the account's
+ * `<provider>.client_id`, WireCat's app. A secret without any of the first three ids is a `configuration_error`.
+ * Undefined when nothing names an app and WireCat has none.
+ */
+export const oauthApp = (options) => {
+    const { env, prefix, provider } = options;
+    const name = `${prefix}_${provider.toUpperCase()}_CLIENT`;
+    const clientSecret = env[`${name}_SECRET`];
+    const own = [
+        [options.clientId, "flag"],
+        [env[`${name}_ID`], "env"],
+        [options.configClientId, "config"],
+    ];
+    const [clientId, source] = own.find(([id]) => id) ?? [];
+    if (clientId && source)
+        return app({ clientId, ...(clientSecret ? { clientSecret } : {}) }, source);
+    if (clientSecret)
+        throw new CliError("configuration_error", `${name}_SECRET is set without a client id; set ${name}_ID too, or unset it to use WireCat's app`, { reason: "sign-in.secret-without-id" });
+    const wirecat = options.wirecat;
+    if (!wirecat?.client_id)
+        return undefined;
+    return app({ clientId: wirecat.client_id, ...(wirecat.client_secret ? { clientSecret: wirecat.client_secret } : {}) }, "constants");
+};
+const app = (client, source) => ({ client: { ...client, source }, source });
+/**
+ * The Google Desktop app a sign-in uses: `--client-file`, then `oauthApp`'s order. Google treats a Desktop app's
+ * secret as public (https://developers.google.com/identity/protocols/oauth2/native-app), so WireCat's ships, obscured,
+ * in cli-core's constants.
+ */
+export const googleApp = (options) => {
+    const { clientFile, platform } = options;
+    if (clientFile)
+        return app(readClientFile(clientFile, platform ? { platform } : {}), "flag");
+    const wirecat = (options.constants ?? constants()).google.app;
+    return oauthApp({ ...options, provider: "google", wirecat });
+};
+/** WireCat's Microsoft app is a public client: it has an id and no secret. */
+export const microsoftApp = (options) => {
+    const wirecat = (options.constants ?? constants()).microsoft.app;
+    return oauthApp({ ...options, provider: "microsoft", wirecat });
+};
+/** `doctor`'s `oauth_client` for one provider: the app a new sign-in would use; doctor reads no keyring. */
+export const oauthClientReport = (app, reason) => app?.source
+    ? { client: app.source === "constants" ? "wirecat" : "own", source: app.source }
+    : { client: null, source: null, ...(reason ? { reason } : {}) };

package/dist/constants/obscure.d.ts

@@ -0,0 +1 @@
+export declare const reveal: (obscured: string) => string;

package/dist/constants/obscure.js

@@ -0,0 +1,9 @@
+import { createDecipheriv } from "node:crypto";
+// Not protection: anyone holding the package can reveal these. It keeps secret scanners and a casual read from
+// treating WireCat's public Desktop app as a leaked credential, as rclone does for its own app.
+const KEY = Buffer.from("d43012779aa2dded3e98092a3dbcf5d8980c564172f5ce0a5fd0574e5f740339", "hex");
+export const reveal = (obscured) => {
+    const bytes = Buffer.from(obscured, "base64url");
+    const decipher = createDecipheriv("aes-256-ctr", KEY, bytes.subarray(0, 16));
+    return Buffer.concat([decipher.update(bytes.subarray(16)), decipher.final()]).toString("utf8");
+};

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

@@ -33,6 +33,7 @@ const SIGN_IN = [
     ["sign-in.client-file-invalid", "configuration_error", "the file is not a Desktop app OAuth client JSON"],
     ["oauth.scope-missing", "permission_error", "the sign-in lacks a permission this command needs"],
     ["sign-in.client-rejected", "configuration_error", "the provider rejected the OAuth client"],
+    ["sign-in.secret-without-id", "configuration_error", "an OAuth client secret is set without its client id"],
 ];
 /** Reasons every CLI over a provider's API raises alike: gcal and drive today. */
 const PROVIDER_API = [
@@ -234,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/oauth/index.d.ts

@@ -1,6 +1,6 @@
 export { type Authorization, type AuthorizeOptions, authorize } from "./authorize.js";
 export { type ClientFileOptions, readClientFile } from "./client-file.js";
 export { type SignInOptions, type TokenKeeper, type TokenKeeperOptions, type TokensOptions, tokenKeeper, } from "./keeper.js";
-export type { ExchangeContext, OAuthClient, OAuthProvider, RequestContext, TokenSet } from "./provider.js";
+export type { AppSource, ExchangeContext, OAuthClient, OAuthProvider, RequestContext, TokenSet } from "./provider.js";
 export { requestTokens, revokeToken, TOKEN_LOG_ALLOW, TOKEN_LOG_EVENT } from "./requests.js";
 export { type CredentialStorageOptions, credentialStorage, driveSessionCodec, type EncodeInput, oauthAccount, type StoredTokens, standardCodec, type TokenCodec, type TokenStorage, zoomTokenCodec, } from "./storage.js";

package/dist/oauth/provider.d.ts

@@ -3,7 +3,12 @@ import type { Logger } from "@wirecat/cli-base";
 export interface OAuthClient {
     clientId: string;
     clientSecret?: string;
+    /** Where the sign-in found the app (WC-SECR-25); saved with the entry, so `doctor` reports the app it used. */
+    source?: AppSource;
 }
+/** `flag`: `--client-file` or `--client-id`; `env`: `<TOOL>_<PROVIDER>_CLIENT_ID`; `config`: the account's
+ * `<provider>.client_id`; `constants`: WireCat's app. */
+export type AppSource = "flag" | "env" | "config" | "constants";
 export interface TokenSet {
     accessToken?: string;
     refreshToken: string;

package/dist/oauth/storage.js

@@ -40,8 +40,9 @@ export const standardCodec = (providerId) => ({
             throw invalid();
         if (!Array.isArray(value.scopes) || !value.scopes.every((scope) => typeof scope === "string"))
             throw invalid();
+        const source = text(value.clientSource);
         return {
-            client: { clientId },
+            client: defined({ clientId, clientSecret: text(value.clientSecret), source }),
             tokens: defined({
                 accessToken: text(value.accessToken),
                 refreshToken,
@@ -57,6 +58,10 @@ export const standardCodec = (providerId) => ({
         version: 1,
         provider: providerId,
         clientId: client.clientId,
+        // Only WireCat's secret, which is public: a later release may ship another default app, and a refresh needs
+        // the secret of the app that signed in. An owner's own secret stays where the owner keeps it.
+        clientSecret: client.source === "constants" ? client.clientSecret : undefined,
+        clientSource: client.source,
         accessToken: tokens.accessToken,
         refreshToken: tokens.refreshToken,
         expiresAt: tokens.expiresAt,
@@ -80,7 +85,11 @@ export const driveSessionCodec = {
         if (!refreshToken || !clientId || typeof value.principal !== "string")
             throw invalid();
         return {
-            client: defined({ clientId, clientSecret: text(value.clientSecret) }),
+            client: defined({
+                clientId,
+                clientSecret: text(value.clientSecret),
+                source: text(value.clientSource),
+            }),
             tokens: defined({
                 accessToken: text(fields.access_token),
                 refreshToken,
@@ -98,6 +107,7 @@ export const driveSessionCodec = {
             ...extra,
             clientId: client.clientId,
             ...(client.clientSecret ? { clientSecret: client.clientSecret } : {}),
+            ...(client.source ? { clientSource: client.source } : {}),
             tokens: defined({
                 ...oldTokens,
                 access_token: tokens.accessToken,

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.565.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",
@@ -19,6 +19,7 @@
   "packageManager": "pnpm@11.28.8",
   "files": [
     "dist",
+    "constants.json",
     "parity.json",
     "skills",
     "README.md",
@@ -166,6 +167,10 @@
     "./oauth": {
       "types": "./dist/oauth/index.d.ts",
       "default": "./dist/oauth/index.js"
+    },
+    "./constants": {
+      "types": "./dist/constants/index.d.ts",
+      "default": "./dist/constants/index.js"
     }
   },
   "scripts": {
@@ -273,7 +278,7 @@
   },
   "peerDependencies": {
     "@napi-rs/canvas": ">=0.1.69 <2",
-    "@wirecat/cli-base": ">=0.75.0 <0.78.0",
+    "@wirecat/cli-base": ">=0.76.0 <0.78.0",
     "commander": ">=15"
   },
   "bin": {