@wirecat/cli-core 0.566.0 → 0.568.0

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

@@ -3,7 +3,7 @@ import { dirname, join } from "node:path";
 import { CliError, resolvePaths, writeSecurely } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Argument, Command, Option } from "commander";
-import { describeWhen, findProgram, lastRun, listSchedules, readSchedule, runSchedule, scheduleFile, scheduleName, timerFor, } from "../../background/schedules.js";
+import { describeWhen, findProgram, lastRun, listSchedules, readSchedule, recordSkip, runSchedule, SCHEDULE_DEFAULTS, scheduleFile, scheduleName, spentToday, timerFor, } from "../../background/schedules.js";
 import { thisMachine } from "../../background/system.js";
 import { locationVariables } from "../../background/units.js";
 import { parseDuration } from "../../domain/duration.js";
@@ -76,12 +76,44 @@ const withWhen = (command) => command
 const promptExample = (app) => app.messenger === false
     ? `summarize what came in during the last day: ${app.command} personal search messages 'date>1d' --newest --limit 20`
     : `run the daily follow-up review: ${app.command} skill show follow-ups`;
+/** The agent-schedule limits a host with `newMail` writes into its config file's top level (WC-CMD-30). */
+export const SCHEDULE_SETTINGS = [
+    {
+        key: "schedule_mail_wait",
+        default: `${SCHEDULE_DEFAULTS.mailWaitMinutes}m`,
+        description: "an agent gated on new mail starts once the oldest waiting email has waited this long",
+    },
+    {
+        key: "schedule_mail_batch",
+        default: SCHEDULE_DEFAULTS.mailBatch,
+        description: "or once this many emails wait for it",
+    },
+    {
+        key: "schedule_max_cost_per_day",
+        default: SCHEDULE_DEFAULTS.maxCostPerDay,
+        description: "US dollars an agent schedule's runs may cost in a day before it waits for the next; 0 for no cap",
+    },
+];
+/** `SCHEDULE_SETTINGS` as the config file gives them; a missing or unusable value is left to the default. */
+export const scheduleLimitsOf = (config) => {
+    const { schedule_mail_wait: wait, schedule_mail_batch: batch, schedule_max_cost_per_day: cap } = config;
+    return {
+        ...(typeof wait === "string"
+            ? { mailWaitMinutes: Math.ceil(parseDuration(wait, "schedule_mail_wait") / 60_000) }
+            : {}),
+        ...(typeof batch === "number" && Number.isSafeInteger(batch) && batch >= 1 ? { mailBatch: batch } : {}),
+        ...(typeof cap === "number" && Number.isFinite(cap) && cap >= 0 ? { maxCostPerDay: cap } : {}),
+    };
+};
+const given = (limits) => Object.fromEntries(Object.entries(limits).filter(([, value]) => value !== undefined));
+const usd = (value) => `$${value.toFixed(2)}`;
 /**
  * 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 const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
+export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: configured, 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);
@@ -117,12 +149,44 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
         };
         return { context, system, state, say, timer, environment, save };
     };
-    /** A schedule gated on new mail waits while nothing is stored past its holder's mark. */
-    const waits = async (self, file) => {
-        const holder = existsSync(file) ? readSchedule(file).onNewMail : undefined;
-        if (holder === undefined || !newMail || (await newMail(self, holder)))
+    /**
+     * Why a run does not start now, or nothing: an agent whose runs reached the day's cost cap waits for tomorrow, and
+     * one gated on mail waits for mail past its holder's mark — on its timer, until enough of it waits.
+     */
+    const waits = async (self, file, { timed }) => {
+        if (!existsSync(file))
+            return undefined;
+        const schedule = readSchedule(file);
+        const { mailWaitMinutes, mailBatch, maxCostPerDay } = {
+            ...SCHEDULE_DEFAULTS,
+            ...given(configured?.(self) ?? {}),
+            ...given({
+                mailWaitMinutes: schedule.mailWaitMinutes,
+                mailBatch: schedule.mailBatch,
+                maxCostPerDay: schedule.maxCostPerDay,
+            }),
+        };
+        if (schedule.kind === "agent" && maxCostPerDay > 0) {
+            const spent = spentToday(file);
+            if (spent >= maxCostPerDay) {
+                const why = `today's runs cost ${usd(spent)}, the ${usd(maxCostPerDay)} a day allowed; it runs again tomorrow`;
+                recordSkip(file, why);
+                return why;
+            }
+        }
+        const holder = schedule.onNewMail;
+        if (holder === undefined || !newMail)
+            return undefined;
+        const waiting = await newMail(self, holder);
+        if (waiting.unmarked)
             return undefined;
-        return holder;
+        if (waiting.emails === 0)
+            return `no mail stored past ${holder}'s mark`;
+        const waited = waiting.oldestStoredAt === null ? 0 : Date.now() - waiting.oldestStoredAt;
+        if (!timed || waiting.emails >= mailBatch || waited >= mailWaitMinutes * 60_000)
+            return undefined;
+        return (`${waiting.emails} email(s) wait past ${holder}'s mark; it starts at ${mailBatch}, ` +
+            `or once the oldest has waited ${mailWaitMinutes}m`);
     };
     withWhen(grantsAuthority(annotate(command.command("command"), {
         literal_after_dashes: true,
@@ -154,19 +218,31 @@ 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)}"`)
-        .addOption(new Option("--max-cost <usd>", "claude only: stop a run that costs more than this, in US dollars").argParser(Number))).action(async function (name, harness, prompt) {
+        .addOption(new Option("--max-cost <usd>", "claude only: stop a run that costs more than this, in US dollars").argParser(Number))
+        .addOption(new Option("--max-cost-per-day <usd>", `claude only: start no run for the rest of the day once its runs cost this much, in US dollars; 0 for no cap (default ${SCHEDULE_DEFAULTS.maxCostPerDay}, or the config file's)`).argParser(Number))).action(async function (name, harness, prompt) {
         const { context, system, environment, save } = prepare(this);
         const options = this.opts();
         if (options.onNewMail !== undefined && !HOLDER.test(options.onNewMail))
             throw new CliError("validation_error", `--on-new-mail takes a holder: lower-case letters, digits and dashes`);
+        if ((options.mailWait !== undefined || options.mailBatch !== undefined) && options.onNewMail === undefined)
+            throw new CliError("validation_error", "--mail-wait and --mail-batch shape a run gated by --on-new-mail");
+        if (options.maxCostPerDay !== undefined && !(Number.isFinite(options.maxCostPerDay) && options.maxCostPerDay >= 0))
+            throw new CliError("validation_error", "--max-cost-per-day takes US dollars, 0 or more");
+        const mailBatch = options.mailBatch === undefined ? undefined : Number(options.mailBatch);
+        if (mailBatch !== undefined && !(Number.isSafeInteger(mailBatch) && mailBatch >= 1))
+            throw new CliError("validation_error", "--mail-batch takes a count of emails, 1 or more");
+        const mailWaitMinutes = options.mailWait === undefined ? undefined : Math.ceil(parseDuration(options.mailWait, "--mail-wait") / 60_000);
         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 +252,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 +263,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({
@@ -204,12 +277,17 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
             environment: environment(),
             createdAt: new Date().toISOString(),
             ...(options.onNewMail ? { onNewMail: options.onNewMail } : {}),
+            ...(mailWaitMinutes === undefined ? {} : { mailWaitMinutes }),
+            ...(mailBatch === undefined ? {} : { mailBatch }),
+            ...(options.maxCostPerDay === undefined ? {} : { maxCostPerDay: options.maxCostPerDay }),
         });
     });
     if (newMail)
         command.commands
             .find((one) => one.name() === "agent")
-            ?.option("--on-new-mail <holder>", `run only when mail is stored past this holder's mark — after a sync brought new mail; may check every ${GATED_AGENT_MINIMUM_MINUTES}m`);
+            ?.option("--on-new-mail <holder>", `run only when mail is stored past this holder's mark — after a sync brought new mail; may check every ${GATED_AGENT_MINIMUM_MINUTES}m`)
+            .option("--mail-wait <duration>", `with --on-new-mail: start once the oldest waiting email has waited this long (default ${SCHEDULE_DEFAULTS.mailWaitMinutes}m, or the config file's)`)
+            .option("--mail-batch <n>", `with --on-new-mail: or once this many emails wait (default ${SCHEDULE_DEFAULTS.mailBatch}, or the config file's)`);
     withQuery(annotate(command.command("list"), {
         effects: LOCAL_READ,
         examples: [`${app.command} personal schedule list`, `${app.command} personal schedule list kind:agent`],
@@ -223,6 +301,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
             kind: schedule.kind,
             when: describeWhen(schedule.when),
             last: lastRun(scheduleFile(state, schedule.name)) ?? null,
+            ...(schedule.kind === "agent" ? { spentTodayUsd: spentToday(scheduleFile(state, schedule.name)) } : {}),
         }));
         const answer = listOf("schedule list", {
             items: rows.map((row) => snakeKeys(row)),
@@ -235,7 +314,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
                 return "";
             }
             return rows
-                .map(({ name, kind, when, last }) => [
+                .map(({ name, kind, when, last, spentTodayUsd }) => [
                 name,
                 kind,
                 when,
@@ -246,6 +325,10 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
                                 `${last.failures} in a row${last.reason ? `: ${last.reason}` : ""} — ${last.output}`
                             : "")
                     : "not run yet",
+                ...(spentTodayUsd ? [`today ${usd(spentTodayUsd)}`] : []),
+                ...(last?.skipped
+                    ? [`skipped ${last.skipped.at.slice(0, 16).replace("T", " ")}: ${last.skipped.why}`]
+                    : []),
             ].join("  "))
                 .join("\n");
         });
@@ -258,11 +341,12 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
         .argument("<name>", "the schedule's name, as `schedule list` shows it")
         .action(async function (name) {
         const { context, system, state, say, timer } = prepare(this);
-        const holder = await waits(this, scheduleFile(state, scheduleName(name)));
-        if (holder !== undefined)
-            return say({ name, skipped: true, holder }, [`${name}: skipped — no mail stored past ${holder}'s mark`]);
+        const why = await waits(this, scheduleFile(state, scheduleName(name)), { timed: false });
+        if (why !== undefined)
+            return say({ name, skipped: true, why }, [`${name}: skipped — ${why}`]);
         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}`]);
@@ -293,10 +377,11 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail }) => {
         .action(async function (file) {
         // A timer starts it with no profile named; the schedule's own environment carries the profile.
         const { context, system, timer } = prepare(this, { needsProfile: false });
-        if ((await waits(this, file)) !== undefined)
+        if ((await waits(this, file, { timed: true })) !== undefined)
             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";
@@ -246,7 +247,7 @@ export const settingsFor = (app, extension = {}) => {
     const declaredSettings = [...SHARED_SETTINGS, ...(extension.settings ?? [])]
         .filter(({ key, default: value }) => allSettings.includes(key) && v.safeParse(readSchema, { defaults: { [key]: value } }).success)
         .map((setting) => ({ ...setting, key: `defaults.${setting.key}` }));
-    // `defaults` needs no field of its own, so it is the one section created: every key then shows (RISK-2125).
+    // `defaults` needs no field of its own, so it is the one section created: every key then shows.
     const withDefaults = (raw, except = []) => withSettingDefaults(isScope(raw) && !Object.hasOwn(raw, "defaults") ? { ...raw, defaults: {} } : raw, declaredSettings.filter(({ key }) => !except.includes(key)));
     const PROFILE = envName(app, "PROFILE");
     const PROFILE_LOCK = envName(app, "PROFILE_LOCK");
@@ -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

@@ -58,6 +58,7 @@ const OTHERS = [
     validation("meeting-findings.dedicated-review", "review meeting findings through the dedicated findings command"),
     validation("evidence-findings.stale", "evidence findings changed since they were read; stage a new batch"),
     validation("mail-findings.stale", "mail findings cite mail that changed since it was read; stage a new batch"),
+    ["mail-findings.not-stored", "not_found", "a mail finding cites an email the store does not hold"],
     validation("mail-findings.partial", "a cited email is not stored whole yet; cite it once it is"),
     validation("evidence-findings.dedicated-review", "review evidence findings through the dedicated findings command"),
     validation("mail-findings.dedicated-review", "review mail findings through the dedicated findings command"),
@@ -66,6 +67,8 @@ const OTHERS = [
     ["extraction.invalid-proposals", "invalid_response", "the model's memory proposals could not be used"],
     validation("extraction.text-too-long", "the text is too long for memory extraction"),
     validation("file.locked", "another process holds the file's lock"),
+    validation("mail.cursor-ahead", "an acknowledge cursor is past the newest stored email"),
+    ["mail.holder-not-yours", "permission_error", "a run moves only the mark of the holder its schedule names"],
     ["mail.source-failed", "provider_error", "the mail server refused or did not complete a request"],
     ["mail.search-refused", "provider_error", "the mail server refused to search a folder"],
     [
@@ -235,7 +238,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/mail/cli/marks.d.ts

@@ -22,6 +22,7 @@ export declare const markItem: (mark: MailMark) => v.InferOutput<typeof mailMark
 export declare const markText: (mark: MailMark) => string;
 /**
  * `messages acknowledge`: a holder says it is done with what `review --holder` gave it, and its mark moves there. It
- * only moves the holder's own bookkeeping forward, so a read-only scheduled run may do it.
+ * only moves the holder's own bookkeeping forward, so a read-only scheduled run may do it — for the holder its
+ * schedule names only: an email that talks its reader into acknowledging would otherwise silence another pipeline.
  */
 export declare const acknowledgeCommand: (mail: MailReads) => Command;

package/dist/mail/cli/marks.js

@@ -1,10 +1,13 @@
+import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import * as v from "valibot";
 import { answerEntity } from "../../cli/answer-entity.js";
-import { outputFor } from "../../cli/context.js";
+import { actorOf } from "../../cli/author.js";
+import { environmentOf, outputFor } from "../../cli/context.js";
 import { LOCAL_WRITE, proposesOnly } from "../../cli/effects.js";
 import { itemOf, renderAnswer } from "../../cli/envelope.js";
+import { mailHolderVariable, readOnlyLockOf } from "../../ports/app.js";
 import { acknowledgeMark } from "../marks.js";
 const iso = (ms) => (ms === null ? null : new Date(ms).toISOString());
 /** A holder's mark as `--json`, `mail status` and MCP show it. */
@@ -38,7 +41,8 @@ export const markText = (mark) => `${mark.holder}  through ${mark.throughId}${ma
     `updated ${iso(mark.updatedAt)}\n`;
 /**
  * `messages acknowledge`: a holder says it is done with what `review --holder` gave it, and its mark moves there. It
- * only moves the holder's own bookkeeping forward, so a read-only scheduled run may do it.
+ * only moves the holder's own bookkeeping forward, so a read-only scheduled run may do it — for the holder its
+ * schedule names only: an email that talks its reader into acknowledging would otherwise silence another pipeline.
  */
 export const acknowledgeCommand = (mail) => answerEntity(proposesOnly(annotate(new Command("acknowledge"), {
     effects: LOCAL_WRITE,
@@ -53,6 +57,13 @@ export const acknowledgeCommand = (mail) => answerEntity(proposesOnly(annotate(n
     .requiredOption("--cursor <cursor>", "the cursor `review --holder` gave")
     .action(async function () {
     const { holder, cursor } = this.opts();
+    const env = environmentOf(this).env ?? process.env;
+    const named = env[mailHolderVariable(mail.app)]?.trim();
+    const owner = actorOf(this) === "owner" && !readOnlyLockOf(mail.app, env);
+    if (named ? named !== holder : !owner)
+        throw new CliError("permission_error", named
+            ? `this run moves only ${named}'s mark, not ${holder}'s`
+            : `an agent moves only the mark of the holder its schedule names (schedule agent --on-new-mail ${holder}); the owner moves any`, { reason: "mail.holder-not-yours" });
     const mark = await mail.read(this, (store, mailbox) => acknowledgeMark(store, mailbox, holder, cursor));
     renderAnswer(this, outputFor(this), itemOf(markItem(mark)), () => markText(mark));
 });

package/dist/mail/cli/review.js

@@ -90,14 +90,16 @@ const reviewAnswer = (found, mailbox, fresh, step) => {
     const cut = found.chats.filter((chat) => chat.more);
     const ref = (thread) => formatReference({ type: "chat", ...mailbox, chat: thread });
     const turns = found.unanswered !== undefined || found.waiting !== undefined;
-    const wholeThreads = cut.flatMap((chat) => step("mail-conversations.show", { conversation: ref(chat.id) }));
+    const [first, ...rest] = cut.map((chat) => ref(chat.id));
+    const wholeThread = first === undefined ? [] : step("mail-conversations.show", { conversation: first });
     const missing = [
-        ...(cut.length > 0
+        ...(first !== undefined
             ? [
                 {
                     field: "items",
-                    why: `only the newest emails of ${cut.length} thread(s)`,
-                    ...(wholeThreads.length ? { step: "mail-conversations.show" } : {}),
+                    why: `only the newest emails of ${cut.length} thread(s)` +
+                        (rest.length ? `; read the others whole the same way: ${rest.join(", ")}` : ""),
+                    ...(wholeThread.length ? { step: "mail-conversations.show" } : {}),
                 },
             ]
             : []),
@@ -117,7 +119,7 @@ const reviewAnswer = (found, mailbox, fresh, step) => {
         ...(!fresh && !turns
             ? step("mail-review.next", { query: `date>${quoted(found.complete ? found.until : found.since)}` })
             : []),
-        ...wholeThreads,
+        ...wholeThread,
     ];
     return listOf("review", {
         items: read.map((message) => ({

package/dist/mail/index.d.ts

@@ -9,7 +9,7 @@ export { dropMissing, type Gone, tooManyGone } from "./gone.js";
 export { type AuthVerdicts, HEADER_FIELDS, headersOf, type MailHeaders, mailHeadersOf } from "./headers.js";
 export { type MailIdsInput, mailIds } from "./ids.js";
 export { decodedLabelName, decodeMailboxName, labelName, systemLabel } from "./labels.js";
-export { acknowledgeMark, cursorOf, HOLD_PARTIAL_MS, HOLDER, holderHasMail, MARK_BATCH, type MailMark, type MarkRead, markOf, marksOf, readPastMark, type SkipReason, } from "./marks.js";
+export { acknowledgeMark, advancePastSkipped, cursorOf, HOLD_PARTIAL_MS, HOLDER, MARK_BATCH, type MailMark, type MailWaiting, type MarkRead, mailWaiting, markOf, marksOf, readPastMark, type SkipReason, } from "./marks.js";
 export { type MailTurn, mailTurn } from "./owed.js";
 export { type Address, htmlToText, looksLikeHtml, MAX_ATTACHMENTS, MAX_BODY_CHARS, type ParsedMail, parseMail, } from "./parse.js";
 export { PARTIAL, type PartialOutcome } from "./partial.js";

package/dist/mail/index.js

@@ -9,7 +9,7 @@ export { dropMissing, tooManyGone } from "./gone.js";
 export { HEADER_FIELDS, headersOf, mailHeadersOf } from "./headers.js";
 export { mailIds } from "./ids.js";
 export { decodedLabelName, decodeMailboxName, labelName, systemLabel } from "./labels.js";
-export { acknowledgeMark, cursorOf, HOLD_PARTIAL_MS, HOLDER, holderHasMail, MARK_BATCH, markOf, marksOf, readPastMark, } from "./marks.js";
+export { acknowledgeMark, advancePastSkipped, cursorOf, HOLD_PARTIAL_MS, HOLDER, MARK_BATCH, mailWaiting, markOf, marksOf, readPastMark, } from "./marks.js";
 export { mailTurn } from "./owed.js";
 export { htmlToText, looksLikeHtml, MAX_ATTACHMENTS, MAX_BODY_CHARS, parseMail, } from "./parse.js";
 export { PARTIAL } from "./partial.js";

package/dist/mail/marks.d.ts

@@ -17,6 +17,8 @@ export interface MailMark {
     /** ms: when the email at `throughId` was received; for display. */
     throughAt: number | null;
     held: number[];
+    /** Emails skipped while their sender looked suspicious; offered again once the sender's score is cleared. */
+    suspicious: number[];
     read: number;
     skipped: Record<SkipReason, number>;
     /** ms. */
@@ -48,13 +50,27 @@ export declare const readPastMark: (store: MessageStore, mailbox: AccountKey, ho
     now?: number;
     limit?: number;
 }) => Promise<MarkRead>;
+/** Mail past a holder's marks that would reach it: how many emails, and when the oldest of them was stored. */
+export interface MailWaiting {
+    /** No mark yet in some mailbox: the holder's first run sets it. */
+    unmarked: boolean;
+    emails: number;
+    /** ms. */
+    oldestStoredAt: number | null;
+}
+/**
+ * What waits for the holder in every stored mailbox, read only: what a schedule asks before it starts the holder's
+ * agent, so a run with nothing new costs no model call. Bulk, envelopes, drafts, suspicious senders and partial mail
+ * do not count.
+ */
+export declare const mailWaiting: (store: MessageStore, holder: string, now?: number) => Promise<MailWaiting>;
 /**
- * Whether the holder has mail to read in any stored mailbox — what a schedule asks before it starts the holder's
- * agent, so a run with nothing new costs no model call. Mail that is only skipped (bulk, envelopes, drafts,
- * suspicious senders) moves the holder's mark here, as the agent would have acknowledged it, or it would wait
- * forever behind the mark. A holder with no mark yet has mail to read: its first run sets the mark.
+ * Moves the holder's mark, in every stored mailbox, over the mail at its head that it would only skip — bulk,
+ * envelopes, drafts, suspicious senders — as the agent would have acknowledged it, so a quiet holder's next check
+ * does not read it all again. Suspicious senders' emails stay on the mark to be offered again. It stops at the first
+ * email the holder reads. A store busy with a sync is left alone: the next check moves it.
  */
-export declare const holderHasMail: (store: MessageStore, holder: string, now?: number) => Promise<boolean>;
+export declare const advancePastSkipped: (store: MessageStore, holder: string, now?: number) => Promise<void>;
 /**
  * Moves the holder's mark to the cursor its read gave, never back. An email whole when it was read counts read; one
  * still partial, or changed after the read (it may have become whole since), is held and comes with the next read.