@wirecat/cli-core 0.462.0 → 0.464.0

package/dist/calendar/testing/writer-contract.d.ts

@@ -17,7 +17,8 @@ export interface CalendarWriterFixture {
 }
 /**
  * What every calendar writer keeps (gcal-cli plan §9, W1): a stale `etag` is a conflict, never an overwrite; a create
- * retried with its id finds the event; `notify: false` mails nobody, and a profile that keeps `events.notify` at its
+ * retried with its id finds the event; a repeat rule is kept as given and changed on the series; a timed event
+ * switches to all-day and back; `notify: false` mails nobody, and a profile that keeps `events.notify` at its
  * default never reaches the provider with a write that would.
  */
 export declare const calendarWriterContract: (fixture: () => CalendarWriterFixture | Promise<CalendarWriterFixture>) => ContractCase[];

package/dist/calendar/testing/writer-contract.js

@@ -17,9 +17,12 @@ const rejectsWith = async (promise, check, message) => {
     assert.fail(`${message}, but it succeeded`);
 };
 const ID = "contract0sample0id0001";
+const WEEKLY = "RRULE:FREQ=WEEKLY;COUNT=3";
+const DAILY = "RRULE:FREQ=DAILY;INTERVAL=2;COUNT=5";
 /**
  * What every calendar writer keeps (gcal-cli plan §9, W1): a stale `etag` is a conflict, never an overwrite; a create
- * retried with its id finds the event; `notify: false` mails nobody, and a profile that keeps `events.notify` at its
+ * retried with its id finds the event; a repeat rule is kept as given and changed on the series; a timed event
+ * switches to all-day and back; `notify: false` mails nobody, and a profile that keeps `events.notify` at its
  * default never reaches the provider with a write that would.
  */
 export const calendarWriterContract = (fixture) => {
@@ -75,6 +78,47 @@ export const calendarWriterContract = (fixture) => {
                         : f.writer.respond(f.calendar, id, "declined", options), (error) => reasonOf(error) === "event.conflict", "a stale etag is a calendarConflict()");
             },
         })),
+        {
+            name: "a create with a repeat rule returns the series holding that rule",
+            run: async () => {
+                const f = await fixture();
+                const made = await f.writer.create(f.calendar, draft(f.at, { recurrence: [WEEKLY] }), {
+                    id: ID,
+                    notify: false,
+                });
+                assert.equal(made.kind, "series");
+                assert.deepEqual(made.recurrence, [WEEKLY]);
+            },
+        },
+        {
+            name: "a change of the series' rule replaces it",
+            run: async () => {
+                const f = await fixture();
+                const made = await f.writer.create(f.calendar, draft(f.at, { recurrence: [WEEKLY] }), {
+                    id: ID,
+                    notify: false,
+                });
+                const changed = await f.writer.update(f.calendar, made.externalId, { recurrence: [DAILY] }, { scope: "series", etag: made.etag, notify: false });
+                assert.deepEqual(changed.recurrence, [DAILY]);
+                assert.notEqual(changed.etag, made.etag);
+            },
+        },
+        {
+            name: "a timed event becomes all-day, and back",
+            run: async () => {
+                const f = await fixture();
+                const made = await f.writer.create(f.calendar, draft(f.at), { id: ID, notify: false });
+                const day = new Date(f.at).toISOString().slice(0, 10);
+                const next = new Date(f.at + 86_400_000).toISOString().slice(0, 10);
+                const allDay = await f.writer.update(f.calendar, made.externalId, { startDate: day, endDate: next, timezone: "UTC" }, { scope: "this", etag: made.etag, notify: false });
+                assert.equal(allDay.allDay, true);
+                assert.equal(allDay.startDate, day);
+                const timed = await f.writer.update(f.calendar, made.externalId, { startsAt: f.at, endsAt: f.at + 3_600_000, timezone: "UTC" }, { scope: "this", etag: allDay.etag, notify: false });
+                assert.equal(timed.allDay ?? false, false);
+                assert.equal(timed.startsAt, f.at);
+                assert.equal(timed.startDate ?? null, null);
+            },
+        },
         {
             name: "notify reaches the provider as given: false mails nobody",
             run: async () => {
@@ -122,7 +166,7 @@ export const calendarWriterContract = (fixture) => {
                     ask: async () => { },
                     now: f.at,
                     zone: "UTC",
-                    names: { notify: "notify", id: "id", calendar: "calendar", series: "series" },
+                    names: { notify: "notify", id: "id", calendar: "calendar", series: "series", repeat: "repeat" },
                 }, String(calendar?.id), {
                     title: "Example planning",
                     startTime: new Date(f.at).toISOString(),

package/dist/calendar/testing/writer.js

@@ -65,7 +65,7 @@ export const fakeCalendarWriter = (options = {}) => {
                 return answer(existing);
             const entry = stamp({
                 externalId: id,
-                kind: "single",
+                kind: draft.recurrence ? "series" : "single",
                 status: "confirmed",
                 participants: [],
                 ...fields(draft),

package/dist/calendar/writer.d.ts

@@ -3,7 +3,8 @@ import type { EntryInput, ParticipantResponse, StoredCalendar } from "../meeting
 import type { Level, PermissionKey } from "../sends/permissions.js";
 /**
  * A new event in neutral words: a timed one has `startsAt` and `endsAt` (epoch ms, end exclusive) in `timezone`; an
- * all-day one has `startDate` and `endDate` (`YYYY-MM-DD`, end exclusive). Never repeating.
+ * all-day one has `startDate` and `endDate` (`YYYY-MM-DD`, end exclusive). A repeating one has `recurrence`, RFC 5545
+ * lines as `EntryInput` holds them; its `timezone` is the zone the rule is expanded in, which Google requires.
  */
 export interface EventDraft {
     title: string;
@@ -18,8 +19,12 @@ export interface EventDraft {
         email: string;
         optional?: boolean;
     }[];
+    recurrence?: string[];
 }
-/** Only the fields to change; `null` clears one. `attendees` replaces the whole list. */
+/**
+ * Only the fields to change; `null` clears one. `attendees` and `recurrence` replace the whole list. A patch with
+ * `startDate` for a timed event, or `startsAt` for an all-day one, switches it: the adapter clears the other kind.
+ */
 export type EventPatch = Partial<EventDraft>;
 /** `this`: the one entry named; `series`: the repeating event it belongs to, named by the series' own id. */
 export type WriteScope = "this" | "series";

package/dist/calendar/writes.d.ts

@@ -29,6 +29,8 @@ export interface EventFields {
     location?: string;
     description?: string;
     attendees?: string[];
+    /** An RFC 5545 rule, with or without `RRULE:`; on a change, only with the series' scope. */
+    repeat?: string;
 }
 export interface WriteContext {
     store: EventStore;
@@ -44,11 +46,16 @@ export interface WriteContext {
         id: string;
         calendar: string;
         series: string;
+        repeat: string;
     };
 }
-/** Typed fields into a draft, or into a patch with only what was given. */
-export declare const draftOf: (fields: EventFields, zone: string, { whole }: {
+/**
+ * Typed fields into a draft, or into a patch with only what was given. `allDay` is the kind of the event a patch
+ * changes, for a repeat rule's UNTIL when the patch keeps the times.
+ */
+export declare const draftOf: (fields: EventFields, zone: string, { whole, allDay }: {
     whole: boolean;
+    allDay?: boolean;
 }) => EventPatch;
 /** An id every provider takes as a client-chosen one: Google's base32hex `[a-v0-9]`, a CalDAV UID, a Graph id. */
 export declare const newEventId: () => string;
@@ -73,6 +80,7 @@ export declare const createEvent: (context: WriteContext, calendarReference: str
         url: string | null;
         deleted_at: string | null;
     } | null;
+    hint?: string | undefined;
 }>;
 export declare const updateEvent: (context: WriteContext, reference: string, fields: EventFields, options?: {
     calendar?: string;
@@ -96,6 +104,7 @@ export declare const updateEvent: (context: WriteContext, reference: string, fie
         url: string | null;
         deleted_at: string | null;
     } | null;
+    hint?: string | undefined;
 }>;
 export declare const deleteEvent: (context: WriteContext, reference: string, options?: {
     calendar?: string;
@@ -128,4 +137,5 @@ export declare const respondToEvent: (context: WriteContext, reference: string,
         url: string | null;
         deleted_at: string | null;
     } | null;
+    hint?: string | undefined;
 }>;

package/dist/calendar/writes.js

@@ -6,6 +6,7 @@ import { guardedWrite } from "../sends/guarded.js";
 import { DEFAULT_PERMISSIONS, levelFor } from "../sends/permissions.js";
 import { newOperationId } from "../sends/send-id.js";
 import { calendarIn, entryItem, eventIdOf, eventOf, plusDays } from "./reads.js";
+import { kindBoundLines, repeatRule } from "./recurrence.js";
 import { CALENDAR_WRITE_DEFAULTS, EVENTS_DELETE_SERIES_KEY, EVENTS_NOTIFY_KEY, } from "./writer.js";
 export const EVENT_RESPONSES = ["accepted", "tentative", "declined"];
 /** Each write is checked by its command's path, the key a declared CLI's `commandPermissions` already knows. */
@@ -24,8 +25,11 @@ const dateOf = (text, what) => {
     return text;
 };
 const momentOf = (text, zone) => zonedMoment(text, zone, { start: 0, end: text.length });
-/** Typed fields into a draft, or into a patch with only what was given. */
-export const draftOf = (fields, zone, { whole }) => {
+/**
+ * Typed fields into a draft, or into a patch with only what was given. `allDay` is the kind of the event a patch
+ * changes, for a repeat rule's UNTIL when the patch keeps the times.
+ */
+export const draftOf = (fields, zone, { whole, allDay = false }) => {
     const patch = {};
     if (fields.title !== undefined) {
         if (!fields.title.trim())
@@ -66,6 +70,12 @@ export const draftOf = (fields, zone, { whole }) => {
                 throw new CliError("validation_error", `${email} is not an email address`);
             return { email };
         });
+    if (fields.repeat !== undefined)
+        patch.recurrence = [
+            repeatRule(fields.repeat, {
+                allDay: patch.startDate !== undefined || (patch.startsAt === undefined && allDay),
+            }),
+        ];
     if (!whole && Object.keys(patch).length === 0)
         throw new CliError("validation_error", "nothing to change");
     return patch;
@@ -130,10 +140,12 @@ const keysFor = (context, write, notify) => [
     ...(context.writes.extraKeys?.(write) ?? []),
     ...(notify ? [EVENTS_NOTIFY_KEY] : []),
 ];
-const answerOf = (operationId, saved) => ({
+const answerOf = (operationId, saved, repeats = false) => ({
     operation_id: operationId,
     event: saved?.eventId == null ? null : `event:${saved.eventId}`,
     entry: saved ? entryItem(saved) : null,
+    // Only the series is saved here; its occurrences come with the provider's expansion on the next sync.
+    ...(repeats ? { hint: "sync to store its occurrences" } : {}),
 });
 /** An id every provider takes as a client-chosen one: Google's base32hex `[a-v0-9]`, a CalDAV UID, a Graph id. */
 export const newEventId = () => randomUUID().replaceAll("-", "");
@@ -159,7 +171,7 @@ export const createEvent = async (context, calendarReference, fields, options =
         throw error;
     }
     const [saved] = await context.store.saveEntries(calendar.id, [entry], context.now);
-    return answerOf(id, saved);
+    return answerOf(id, saved, draft.recurrence !== undefined);
 };
 const targetOf = async (context, reference, { calendar, scope }) => {
     const details = await eventOf(context.store, context.accountId, eventIdOf(reference));
@@ -196,14 +208,28 @@ const targetOf = async (context, reference, { calendar, scope }) => {
     };
 };
 export const updateEvent = async (context, reference, fields, options = {}) => {
-    const patch = draftOf(fields, context.zone, { whole: false });
     const scope = options.series ? "series" : "this";
+    if (fields.repeat !== undefined && scope !== "series")
+        throw new CliError("validation_error", `a repeat rule belongs to the whole series: add ${context.names.series}`, {
+            param: context.names.series,
+        });
     const { calendar, target, participants } = await targetOf(context, reference, { ...options, scope });
+    const patch = draftOf(fields, context.zone, { whole: false, allDay: target.allDay });
+    const kept = (target.recurrence ?? []).filter((line) => !/^RRULE:/iu.test(line));
+    if (patch.recurrence)
+        patch.recurrence = [...patch.recurrence, ...kept];
+    const switching = patch.startDate !== undefined ? !target.allDay : patch.startsAt !== undefined && target.allDay;
+    const bound = kindBoundLines(patch.recurrence ? kept : (target.recurrence ?? []));
+    if (switching && bound.length)
+        throw new CliError("validation_error", `${reference} repeats with ${bound.join(", ")}, which hold a ${target.allDay ? "date" : "time"}; ` +
+            (patch.recurrence || bound.some((line) => !/^RRULE:/iu.test(line))
+                ? "change its kind in the calendar itself"
+                : `give its rule again with ${context.names.repeat} and UNTIL as a ${target.allDay ? "UTC time" : "date"}`), { reason: "event.repeat-kind" });
     const notify = notifyOf(context, options.notify, hasOthers(participants) || (patch.attendees?.length ?? 0) > 0);
     const operationId = newOperationId();
     const entry = await guardedWrite(writeGuard(context, keysFor(context, "update", notify)), { chatId: null, kind: "edit", key: COMMAND_KEY.update, operationId, notify }, () => context.writes.writer.update(calendar, target.externalId, patch, { scope, etag: target.etag, notify }));
     const [saved] = await context.store.saveEntries(calendar.id, [entry], context.now);
-    return answerOf(operationId, saved);
+    return answerOf(operationId, saved, patch.recurrence !== undefined || (switching && scope === "series"));
 };
 export const deleteEvent = async (context, reference, options = {}) => {
     const scope = options.series ? "series" : "this";

package/dist/cli/bot/mcp.js

@@ -12,8 +12,16 @@ import { botExamples } from "./examples.js";
 /** `bot mcp`, mounted only for a messenger that hands in its `run` on `BotMessenger.mcp`. */
 export const botMcpCommand = (bot) => {
     const { app } = bot;
-    const command = annotate(new Command("mcp"), { effects: REMOTE_WRITE, lifetime: "persistent", mcp: false })
-        .description(`serve this bot to an agent over MCP, on stdin and stdout — \`claude mcp add sales-bot -- ${app.command} sales bot mcp\``)
+    const command = annotate(new Command("mcp"), { effects: LOCAL_READ, mcp: false })
+        .description(`serve this bot to an agent over MCP and set it up — \`claude mcp add sales-bot -- ${app.command} sales bot mcp serve\``)
+        .summary("serve this bot to an agent over MCP, and set that up");
+    command.addCommand(annotate(new Command("serve"), {
+        effects: REMOTE_WRITE,
+        lifetime: "persistent",
+        mcp: false,
+        examples: botExamples(bot, "mcp serve"),
+    })
+        .description(`serve this bot to an agent over MCP, on stdin and stdout — \`claude mcp add sales-bot -- ${app.command} sales bot mcp serve\``)
         .summary("serve this bot to an agent over MCP, on stdin and stdout")
         .action(async function () {
         const context = botContext(this, bot);
@@ -35,7 +43,7 @@ export const botMcpCommand = (bot) => {
             ...(mcp.keyOf ? { keyOf: mcp.keyOf } : {}),
             ...(mcp.skill ? { skill: mcp.skill } : {}),
         }, context.streams.diagnostic);
-    });
+    }));
     command.addCommand(annotate(new Command("config"), { effects: LOCAL_READ, examples: botExamples(bot, "mcp config") })
         .description("print the mcpServers entry for Claude Desktop, Cursor and others, with full paths; writes nothing")
         .summary("print the mcpServers entry for an MCP client; writes nothing")

package/dist/cli/context.d.ts

@@ -1,6 +1,7 @@
 import { type KeyringStore, type Renderer, type RenderFormat, type Streams } from "@wirecat/cli-base";
 import type { ErrorObject } from "@wirecat/cli-base/standards";
 import type { Command } from "commander";
+import { type Deadline, type RunBudget } from "../background/budget.js";
 import type { MessageEvent } from "../domain/models.js";
 import type { AppIdentity } from "../ports/app.js";
 import type { MessengerAdapter } from "../ports/messenger.js";
@@ -71,6 +72,8 @@ export interface BaseEnvironment {
      * what each step brings and may stop at any point: the history a phone pushes after linking.
      */
     untilStopped?: () => AbortSignal;
+    /** Set by `run()`: the deadline running now, or none (a persistent command, a phase, a background job). */
+    deadline?: () => Deadline | undefined;
     /**
      * Set by `run()`: ends the phase `untilStopped()` began without aborting its signal — the command saw it finish.
      * However a phase ends, the steps after it get the command's one-shot deadline again, started afresh, and a signal
@@ -101,6 +104,11 @@ export interface RelayedRun {
     /** A promise when the lender opens it on first use. */
     connection: () => MessengerAdapter | Promise<MessengerAdapter>;
 }
+/**
+ * A budget for a resumable sync, from the deadline running now and the CLI's `requestMs`: so a lower `--timeout`
+ * means fewer requests. `requests` (`--max-pages`) can only lower it.
+ */
+export declare const runBudgetOf: (command: Command, requests?: number) => RunBudget;
 /** A partial answer's exit code, for this run alone. */
 export declare const setExitCode: (command: Command, code: number) => void;
 export declare const provide: (program: Command, environment: BaseEnvironment) => void;

package/dist/cli/context.js

@@ -1,4 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
+import { runBudget } from "../background/budget.js";
 import { resolveOutput } from "../output.js";
 import { recorded } from "../runs/recording.js";
 import { runContextOf } from "../runs/run-context.js";
@@ -6,6 +7,20 @@ import { withDeadline } from "./deadline.js";
 import { withAbort } from "./execution.js";
 import { rootOf } from "./profile.js";
 import { namedProfile } from "./settings.js";
+/**
+ * A budget for a resumable sync, from the deadline running now and the CLI's `requestMs`: so a lower `--timeout`
+ * means fewer requests. `requests` (`--max-pages`) can only lower it.
+ */
+export const runBudgetOf = (command, requests) => {
+    const { deadline, signal, app } = environmentOf(command);
+    const now = deadline?.();
+    return runBudget({
+        ...(requests === undefined ? {} : { requests }),
+        ...(app?.requestMs === undefined ? {} : { requestMs: app.requestMs }),
+        ...(now ? { deadline: now } : {}),
+        ...(signal ? { signal } : {}),
+    });
+};
 /** A partial answer's exit code, for this run alone. */
 export const setExitCode = (command, code) => {
     const slot = environmentOf(command).exit;

package/dist/cli/execution.d.ts

@@ -1,6 +1,13 @@
 import { type Streams } from "@wirecat/cli-base";
 import type { Closeable } from "./deadline.js";
 export declare const DEFAULT_COMMAND_MS = 30000;
+/** A `cooperative` command stops on its own before its deadline and keeps its work, so it may run longer. */
+export declare const DEFAULT_COOPERATIVE_MS: number;
+/**
+ * The same over MCP: clients cut a tool call at about 60 s (the MCP TypeScript SDK's `DEFAULT_REQUEST_TIMEOUT_MSEC`
+ * is 60000), so the command answers well before that.
+ */
+export declare const DEFAULT_AGENT_COOPERATIVE_MS = 45000;
 export declare const DEFAULT_OUTPUT_BYTES: number;
 export declare const byteCount: (value: string, option: string, zero?: boolean) => number;
 export interface Execution {

package/dist/cli/execution.js

@@ -2,6 +2,13 @@ import { CliError } from "@wirecat/cli-base";
 import { stopWrites, withWriteScope } from "../sends/guarded.js";
 import { fieldsOf, projectFields } from "./result-fields.js";
 export const DEFAULT_COMMAND_MS = 30_000;
+/** A `cooperative` command stops on its own before its deadline and keeps its work, so it may run longer. */
+export const DEFAULT_COOPERATIVE_MS = 5 * 60_000;
+/**
+ * The same over MCP: clients cut a tool call at about 60 s (the MCP TypeScript SDK's `DEFAULT_REQUEST_TIMEOUT_MSEC`
+ * is 60000), so the command answers well before that.
+ */
+export const DEFAULT_AGENT_COOPERATIVE_MS = 45_000;
 export const DEFAULT_OUTPUT_BYTES = 4 * 1024 * 1024;
 export const byteCount = (value, option, zero = false) => {
     const result = Number(value);

package/dist/cli/guide.js

@@ -291,7 +291,7 @@ export const checkStep = (program, run) => {
     const beforeDashes = rest.slice(index, rest.includes("--") ? rest.indexOf("--") : undefined);
     if (help && beforeDashes.some((word) => word === help.long || word === help.short))
         return [];
-    // A group with an action of its own runs as typed: `mcp` serves, `mcp server start` is its child.
+    // A group with an action of its own runs as typed rather than asking for one of its children.
     const runsItself = at._actionHandler != null;
     if (at.commands.length > 0 && !runsItself)
         return [`needs one of: ${at.commands.map((one) => one.name()).join(", ")}`];

package/dist/cli/index.d.ts

@@ -57,7 +57,7 @@ export { CONTRACT } from "./commands-command.js";
 export { refuseUnknownKey } from "./config-command.js";
 export { type ConfigIssue, type ConfigIssueKind, checkConfigText, issueMessage, readConfigFile, readConfigText, settingPathOf, withoutSetting, } from "./config-issues.js";
 export { loadSnakeCaseConfig } from "./config-keys.js";
-export { type AgentRun, type BaseContext, type BaseEnvironment, baseContext, environmentOf, outputFor, provide, secretInputOf, } from "./context.js";
+export { type AgentRun, type BaseContext, type BaseEnvironment, baseContext, environmentOf, outputFor, provide, runBudgetOf, secretInputOf, } from "./context.js";
 export { addContractInfo, type ContractEvidenceOptions, contractEvidence } from "./contract-evidence.js";
 export { sharedCommandTemplate } from "./contract-templates.js";
 export { type Closeable, withDeadline } from "./deadline.js";

package/dist/cli/index.js

@@ -50,7 +50,7 @@ export { CONTRACT } from "./commands-command.js";
 export { refuseUnknownKey } from "./config-command.js";
 export { checkConfigText, issueMessage, readConfigFile, readConfigText, settingPathOf, withoutSetting, } from "./config-issues.js";
 export { loadSnakeCaseConfig } from "./config-keys.js";
-export { baseContext, environmentOf, outputFor, provide, secretInputOf, } from "./context.js";
+export { baseContext, environmentOf, outputFor, provide, runBudgetOf, secretInputOf, } from "./context.js";
 export { addContractInfo, contractEvidence } from "./contract-evidence.js";
 export { sharedCommandTemplate } from "./contract-templates.js";
 export { withDeadline } from "./deadline.js";

package/dist/cli/mcp-server-command.d.ts

@@ -10,7 +10,7 @@ export interface McpServerTarget {
     envPrefix: string;
     env: NodeJS.ProcessEnv;
     tokenFile: string;
-    /** The words after the CLI's own entry that run `mcp --http` in the foreground, before `--port`. */
+    /** The words after the CLI's own entry that run `mcp serve --http` in the foreground, before `--port`. */
     argv: string[];
     /** Added to the server's environment: the profile, for a CLI that reads it from there. */
     childEnv?: Record<string, string>;
@@ -19,17 +19,22 @@ export interface McpServerTarget {
 export interface McpServerOptions {
     /** How help shows the CLI before `mcp`: `tg personal`. */
     example: string;
-    /** The CLI's own `mcp --http` default, when it is not 8765. */
+    /** The CLI's own `mcp serve --http` default, when it is not 8765. */
     defaultPort?: number;
+    /**
+     * `start` takes `--permission` and hands it to the server: only for a CLI whose `mcp serve` takes it too,
+     * since a server that refuses the option dies before it listens.
+     */
+    permission?: boolean;
     target: (self: Command) => McpServerTarget;
     /** The CLI's own answer: the item in `--json`, else the lines. */
     answer: (self: Command, item: object, lines: string[]) => void;
     system?: (self: Command) => ServerSystem | undefined;
 }
 /**
- * `mcp --http` in the background: `start`, `stop`, `status`, as `server` does for `serve`. The server
+ * `mcp serve --http` in the background: `start`, `stop`, `status`, as `server` does for `serve`. The server
  * keeps a lock beside its token file (`state.ts`) with its port, address and login code, so status
  * survives the shell that started it, and `stop` ends only a process that carries this CLI's marker.
  * None of it is offered over MCP: status holds a live login code.
  */
-export declare const mcpServerCommand: ({ example, defaultPort, target, answer, system, }: McpServerOptions) => Command;
+export declare const mcpServerCommand: ({ example, defaultPort, permission, target, answer, system, }: McpServerOptions) => Command;

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

@@ -1,11 +1,11 @@
-import { CliError } from "@wirecat/cli-base";
+import { CliError, writeSecurely } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { alive, carries } from "../background/processes.js";
 import { thisMachine } from "../background/system.js";
 import { readableLog, tail } from "../background/units.js";
 import { mcpUrlOf, portOf, publicUrlOf } from "../http/public-url.js";
-import { httpLockFile, httpLogFile, mcpHttpMarker, readHttpLock, signedInClients, } from "../mcp/http/state.js";
+import { httpLaunchFile, httpLockFile, httpLogFile, mcpHttpMarker, readHttpLock, signedInClients, } from "../mcp/http/state.js";
 import { destroysNothing, LOCAL_READ, LOCAL_WRITE } from "./effects.js";
 export const MCP_HTTP_DEFAULT_PORT = 8765;
 const LOOKS = 120;
@@ -40,28 +40,29 @@ const clientLines = (clients) => clients.length === 0
             .join(", ")}.`,
     ];
 /**
- * `mcp --http` in the background: `start`, `stop`, `status`, as `server` does for `serve`. The server
+ * `mcp serve --http` in the background: `start`, `stop`, `status`, as `server` does for `serve`. The server
  * keeps a lock beside its token file (`state.ts`) with its port, address and login code, so status
  * survives the shell that started it, and `stop` ends only a process that carries this CLI's marker.
  * None of it is offered over MCP: status holds a live login code.
  */
-export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT, target, answer, system, }) => {
+export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT, permission = false, target, answer, system, }) => {
     const command = annotate(new Command("server"), { effects: LOCAL_READ, mcp: false })
         .summary("run the HTTP MCP server in the background")
-        .description("start, stop and check `mcp --http` in the background; status shows the login code for a browser app");
+        .description("start, stop and check `mcp serve --http` in the background; status shows the login code for a browser app");
     const machine = (self) => system?.(self) ?? thisMachine();
-    destroysNothing(annotate(command.command("start"), {
+    const start = destroysNothing(annotate(command.command("start"), {
         effects: LOCAL_WRITE,
         mcp: false,
         examples: [`${example} mcp server start --public-url https://laptop.example.ts.net`],
     }))
         .summary("start the HTTP MCP server in the background")
-        .description("start `mcp --http` apart from this shell and answer once it listens, with its login code")
+        .description("start `mcp serve --http` apart from this shell and answer once it listens, with its login code")
         .option("--port <port>", `the local port (default ${defaultPort})`)
-        .option("--public-url <url>", "the tunnel's https address the browser apps use, e.g. https://<name>.ts.net or https://<name>.ts.net/tg")
-        .option("--permission <key=level>", "make a permission stricter for this server only; repeat for more keys", (value, previous = []) => [...previous, value])
-        .action(async function () {
-        // A CLI whose `mcp` takes the same flags reads them first, so they are looked up on both.
+        .option("--public-url <url>", "the tunnel's https address the browser apps use, e.g. https://<name>.ts.net or https://<name>.ts.net/tg");
+    if (permission)
+        start.option("--permission <key=level>", "make a permission stricter for this server only; repeat for more keys", (value, previous = []) => [...previous, value]);
+    start.action(async function () {
+        // A CLI with a root-wide `--permission` hands it over too, so the server is never looser than asked.
         const flags = this.optsWithGlobals();
         const one = target(this);
         const url = publicUrlOf(flags.publicUrl, {
@@ -81,14 +82,20 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
         const sys = machine(this);
         const log = httpLogFile(one.tokenFile);
         const { [`${one.envPrefix}_TIMEOUT`]: _timeout, ...inherited } = one.env;
-        const pid = sys.spawn([
-            ...one.argv,
-            "--port",
-            String(port),
-            "--public-url",
-            url.pathname === "/" ? url.origin : url.href,
-            ...(flags.permission ?? []).flatMap((entry) => ["--permission", entry]),
-        ], { ...inherited, ...one.childEnv, [mcpHttpMarker(one.envPrefix)]: one.profile ?? "default" }, log);
+        const launch = {
+            invocation: one.invocation,
+            argv: [
+                ...one.argv,
+                "--port",
+                String(port),
+                "--public-url",
+                url.pathname === "/" ? url.origin : url.href,
+                ...(flags.permission ?? []).flatMap((entry) => ["--permission", entry]),
+            ],
+            env: { ...one.childEnv, [mcpHttpMarker(one.envPrefix)]: one.profile ?? "default" },
+        };
+        writeSecurely(httpLaunchFile(lockFile), `${JSON.stringify(launch)}\n`, 0o600);
+        const pid = sys.spawn(launch.argv, { ...inherited, ...launch.env }, log);
         for (let look = 0; look < LOOKS; look++) {
             const now = readHttpLock(lockFile);
             if (now?.pid === pid && now.listeningAt) {
@@ -102,15 +109,15 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
             }
             if (!alive(pid)) {
                 const last = readableLog(tail(log, 5)).trim();
-                throw new CliError("provider_unavailable", `mcp --http stopped before it listened${last ? `:\n${last}` : ""}`);
+                throw new CliError("provider_unavailable", `mcp serve --http stopped before it listened${last ? `:\n${last}` : ""}`, { retryable: false });
             }
             await sys.pause();
         }
-        throw new CliError("timeout", `mcp --http is running but not listening yet — \`${one.invocation} mcp server status\`; its log: ${log}`);
+        throw new CliError("timeout", `mcp serve --http is running but not listening yet — \`${one.invocation} mcp server status\`; its log: ${log}`);
     });
     destroysNothing(annotate(command.command("stop"), { effects: LOCAL_WRITE, mcp: false, examples: [`${example} mcp server stop`] }))
         .summary("stop the background HTTP MCP server")
-        .description("stop `mcp --http` — only one that `mcp server start` started")
+        .description("stop `mcp serve --http` — only one that `mcp server start` started")
         .action(async function () {
         const one = target(this);
         const lock = readHttpLock(httpLockFile(one.tokenFile));
@@ -121,14 +128,14 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
             return;
         }
         if (byOf(one, lock.pid) !== "server") {
-            throw new CliError("validation_error", `mcp --http for ${one.invocation} (PID ${lock.pid}) was not started by \`${one.invocation} mcp server start\` — stop it where it runs`);
+            throw new CliError("validation_error", `mcp serve --http for ${one.invocation} (PID ${lock.pid}) was not started by \`${one.invocation} mcp server start\` — stop it where it runs`);
         }
         process.kill(lock.pid, "SIGTERM");
         const sys = machine(this);
         for (let look = 0; look < LOOKS && alive(lock.pid); look++)
             await sys.pause();
         if (alive(lock.pid))
-            throw new CliError("timeout", `mcp --http (PID ${lock.pid}) has not stopped yet`);
+            throw new CliError("timeout", `mcp serve --http (PID ${lock.pid}) has not stopped yet`);
         answer(this, { profile: one.profile ?? null, stopped: true, pid: lock.pid }, [
             `Stopped serving ${one.invocation} over HTTP (PID ${lock.pid}).`,
         ]);
@@ -139,7 +146,7 @@ export const mcpServerCommand = ({ example, defaultPort = MCP_HTTP_DEFAULT_PORT,
         examples: [`${example} mcp server status --json`],
     })
         .summary("whether the HTTP MCP server runs, its login code and the apps logged in")
-        .description("whether `mcp --http` runs, on which port and address, the login code for a new browser app, and the apps logged in")
+        .description("whether `mcp serve --http` runs, on which port and address, the login code for a new browser app, and the apps logged in")
         .action(function () {
         const one = target(this);
         const lock = readHttpLock(httpLockFile(one.tokenFile));

package/dist/cli/meeting-preparation-answer.d.ts

@@ -320,6 +320,7 @@ export declare const meetingPreparationAnswer: (packet: MeetingPreparation) => i
                     started_at: string | null;
                     url: string | null;
                 } | undefined;
+                untrusted?: string[] | undefined;
             }[];
             association: "unconfirmed-word-evidence";
             vocabulary_fingerprint: string;

package/dist/cli/meeting-preparation-projects.d.ts

@@ -40,6 +40,7 @@ export declare const mapPreparationProjectEvidence: (section: NonNullable<Meetin
                 started_at: string | null;
                 url: string | null;
             } | undefined;
+            untrusted?: string[] | undefined;
         }[];
         association: "unconfirmed-word-evidence";
         vocabulary_fingerprint: string;

package/dist/cli/meeting-preparation-read.d.ts

@@ -349,6 +349,7 @@ export declare const readMeetingPreparation: (read: MeetingPreparationReader, in
                     started_at: string | null;
                     url: string | null;
                 } | undefined;
+                untrusted?: string[] | undefined;
             }[];
             association: "unconfirmed-word-evidence";
             vocabulary_fingerprint: string;

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

@@ -139,6 +139,7 @@ export const topicAnswer = (topic) => defined({
     unread_count: topic.unreadCount,
     last_message_at: topic.lastMessageAt,
     created_at: topic.createdAt,
+    untrusted: ["title"],
 });
 export const folderAnswer = (folder) => {
     const shown = "chats" in folder ? folder : undefined;

package/dist/cli/messenger/mcp-command.d.ts

@@ -17,11 +17,10 @@ export interface McpFlags {
     http?: boolean;
     port?: string;
     publicUrl?: string;
-    revoke?: boolean;
 }
-/** The token file of `<tool> mcp --http` for every profile: no profile name can start with `_`. */
+/** The token file of `<tool> mcp serve --http` for every profile: no profile name can start with `_`. */
 export declare const ALL_PROFILES = "_all";
-/** Where `mcp --http` keeps the hashes of the tokens it issued — per profile, in the state folder. */
+/** Where `mcp serve --http` keeps the hashes of the tokens it issued — per profile, in the state folder. */
 export declare const httpTokenFile: (app: AppIdentity, profile: string, env: NodeJS.ProcessEnv) => string;
 export declare const mcpCommand: (messenger: Messenger) => Command;
 /**
@@ -44,7 +43,7 @@ export declare const redactTail: (text: string, home: string | undefined) => str
  * servers with a trimmed environment leaves it out (measured 2026-09-28). Credentials are never copied.
  */
 export declare const serverEntry: (app: AppIdentity, { profile, flags, execPath, scriptPath, env, }: {
-    /** Left out, the entry is `<tool> mcp`, the server of every profile. */
+    /** Left out, the entry is `<tool> mcp serve`, the server of every profile. */
     profile?: string;
     flags?: McpFlags;
     execPath: string;