@wirecat/cli-core 0.462.0 → 0.464.0

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

@@ -19,31 +19,36 @@ import { nextStep } from "../steps.js";
 import { recalledAccount } from "./accounts.js";
 import { messengerContext } from "./context.js";
 const DEFAULT_PORT = MCP_HTTP_DEFAULT_PORT;
-/** 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 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 const httpTokenFile = (app, profile, env) => join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "mcp-http", `${profile}.json`);
 const withFlags = (command) => command.option("--permission <key=level>", "make a permission stricter for this server only, like messages.send=deny; it never loosens the profile; repeat for more keys", (value, previous = []) => [...previous, value]);
 export const mcpCommand = (messenger) => {
     const { app } = messenger;
-    const command = withFlags(annotate(new Command("mcp"), { effects: REMOTE_WRITE, lifetime: "persistent", mcp: false })
+    const command = annotate(new Command("mcp"), { effects: LOCAL_READ, mcp: false })
+        .summary("serve this profile's commands to an AI agent, and set that up")
+        .description(`serve this profile to an agent over MCP and set it up — \`claude mcp add ${app.command} -- ${app.command} <profile> mcp serve\``);
+    command.addCommand(withFlags(annotate(new Command("serve"), {
+        effects: REMOTE_WRITE,
+        lifetime: "persistent",
+        mcp: false,
+        examples: [
+            `${app.command} personal mcp serve`,
+            `${app.command} personal mcp serve --http --public-url https://laptop.example.ts.net`,
+        ],
+    })
         .summary("serve this profile's commands to an AI agent")
-        .description(`serve this profile to an agent over MCP, on stdin and stdout — \`claude mcp add ${app.command} -- ${app.command} <profile> mcp\`; with no profile, \`${app.command} mcp\` serves every profile and each tool asks which`))
+        .description(`serve this profile to an agent over MCP, on stdin and stdout — \`claude mcp add ${app.command} -- ${app.command} <profile> mcp serve\`; with no profile, \`${app.command} mcp serve\` serves every profile and each tool asks which`))
         .option("--http", "serve over HTTP on 127.0.0.1 for ChatGPT and Claude in the browser, behind your tunnel; the profile's permissions decide")
         .option("--port <port>", `the local port for --http (default ${DEFAULT_PORT})`)
         .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("--revoke", "forget every login given to a browser app; each must log in again");
-    command.action(async function () {
+        .action(async function () {
         const flags = this.optsWithGlobals();
         const context = messengerContext(this, messenger, { needsProfile: false });
-        if (namedProfile(context.settings) === undefined)
+        const profile = namedProfile(context.settings);
+        if (profile === undefined)
             return serveEveryProfile(this, context, messenger, flags);
-        if (flags.revoke) {
-            const { revokeAll } = await import("../../mcp/http/oauth.js");
-            revokeAll(httpTokenFile(app, context.settings.profile, context.env));
-            renderAnswer(this, context, itemOf({ revoked: true, profile: context.settings.profile }));
-            return;
-        }
         if (flags.http) {
             const publicUrl = publicUrlOf(flags.publicUrl, {
                 missing: "--http",
@@ -51,7 +56,7 @@ export const mcpCommand = (messenger) => {
                 path: true,
             });
             const { serveOverHttpUntilStopped } = await import("../../mcp/server.js");
-            const tokenFile = httpTokenFile(app, context.settings.profile, context.env);
+            const tokenFile = httpTokenFile(app, profile, context.env);
             await serveOverHttpUntilStopped(this, context, messenger, {}, {
                 publicUrl,
                 port: portOf(flags.port, DEFAULT_PORT),
@@ -64,9 +69,24 @@ export const mcpCommand = (messenger) => {
         // Loaded here, not at the top: every other command would otherwise pay for the SDK.
         const { serveOverStdio } = await import("../../mcp/server.js");
         await serveOverStdio(this, context, messenger, {});
-    });
+    }));
+    command.addCommand(annotate(new Command("revoke"), {
+        effects: LOCAL_WRITE,
+        mcp: false,
+        examples: [`${app.command} personal mcp revoke`],
+    })
+        .summary("forget every login given to a browser app")
+        .description(`forget every login \`mcp serve --http\` gave a browser app, of this profile or, with no profile, of the server of every profile; each app must log in again`)
+        .action(async function () {
+        const context = messengerContext(this, messenger, { needsProfile: false });
+        const profile = namedProfile(context.settings);
+        const { revokeAll } = await import("../../mcp/http/oauth.js");
+        revokeAll(httpTokenFile(app, profile ?? ALL_PROFILES, context.env));
+        renderAnswer(this, context, itemOf({ revoked: true, profile: profile ?? null }));
+    }));
     command.addCommand(mcpServerCommand({
         example: `${app.command} personal`,
+        permission: true,
         target: (self) => {
             const { settings, env } = messengerContext(self, messenger, { needsProfile: false });
             if (namedProfile(settings) === undefined)
@@ -75,7 +95,7 @@ export const mcpCommand = (messenger) => {
                     envPrefix: app.envPrefix,
                     env,
                     tokenFile: httpTokenFile(app, ALL_PROFILES, env),
-                    argv: ["mcp", "--http"],
+                    argv: ["mcp", "serve", "--http"],
                     version: app.version,
                 };
             return {
@@ -84,7 +104,7 @@ export const mcpCommand = (messenger) => {
                 envPrefix: app.envPrefix,
                 env,
                 tokenFile: httpTokenFile(app, settings.profile, env),
-                argv: ["mcp", "--http"],
+                argv: ["mcp", "serve", "--http"],
                 childEnv: { [`${app.envPrefix}_PROFILE`]: settings.profile },
                 version: app.version,
             };
@@ -194,22 +214,17 @@ export const mcpCommand = (messenger) => {
     return command;
 };
 /**
- * `<tool> mcp` with no profile: every profile on this computer, each call in that profile's own `<tool> <profile> mcp`
+ * `<tool> mcp serve` with no profile: every profile on this computer, each call in that profile's own
+ * `<tool> <profile> mcp serve`
  * (`src/mcp/all-profiles.ts`). Nothing picks a profile: each tool takes one, and the agent is told to ask.
  */
 const serveEveryProfile = async (self, context, messenger, flags) => {
     const { app } = messenger;
     const { env } = context;
     const tokenFile = httpTokenFile(app, ALL_PROFILES, env);
-    if (flags.revoke) {
-        const { revokeAll } = await import("../../mcp/http/oauth.js");
-        revokeAll(tokenFile);
-        renderAnswer(self, context, itemOf({ revoked: true, profile: null }));
-        return;
-    }
     const profiles = () => messenger.resolveSettings(self.optsWithGlobals(), { env, needsProfile: false, readOnly: true }).profilesHere;
     if (profiles().length === 0)
-        throw new CliError("configuration_error", `no ${app.command} profile on this computer yet — set one up, then run \`${app.command} mcp\` again`);
+        throw new CliError("configuration_error", `no ${app.command} profile on this computer yet — set one up, then run \`${app.command} mcp serve\` again`);
     const given = environmentOf(self).mcp ?? {};
     const execPath = given.execPath ?? process.execPath;
     const scriptPath = given.scriptPath ?? realpathSync(process.argv[1] ?? "");
@@ -220,7 +235,7 @@ const serveEveryProfile = async (self, context, messenger, flags) => {
         version: app.version,
         name: messenger.name ?? app.command,
         profiles,
-        child: (profile) => ({ command: execPath, args: [scriptPath, profile, "mcp", ...tightened], env }),
+        child: (profile) => ({ command: execPath, args: [scriptPath, profile, "mcp", "serve", ...tightened], env }),
         instructions: instructions({
             command: app.command,
             name: messenger.name ?? app.command,
@@ -337,6 +352,7 @@ export const serverEntry = (app, { profile, flags = {}, execPath, scriptPath, en
             scriptPath,
             ...(profile === undefined ? [] : [profile]),
             "mcp",
+            "serve",
             ...(flags.permission ?? []).flatMap((entry) => ["--permission", entry]),
         ],
         ...(Object.keys(directories).length > 0 ? { env: directories } : {}),

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

@@ -10,6 +10,16 @@ export const SOURCE_SEARCHED = ["messages", "notes", "events", "meetings"];
 const defined = (value) => Object.fromEntries(Object.entries(value).filter(([, one]) => one !== undefined));
 /** The page a `--page` asks for, as the offset the search services take. */
 export const offsetOf = (page, limit) => page === undefined || page <= 1 ? undefined : (page - 1) * limit;
+/** Who wrote it and what, the chat's title, the mail's headers: others write them; the owner's own messages too. */
+const MESSAGE_HIT_UNTRUSTED = ["chat_title", "sender_name", "excerpt", "context.sender_name", "context.text"];
+const MAIL_HIT_UNTRUSTED = [
+    "email.subject",
+    "email.from.name",
+    "email.to.name",
+    "email.cc.name",
+    "email.bcc.name",
+    "email.reply_addresses.name",
+];
 export const messageHitItem = (hit, query = "") => {
     const at = parseLocator(hit.locator);
     const around = hit.thread?.items ?? hit.context;
@@ -55,6 +65,7 @@ export const messageHitItem = (hit, query = "") => {
             sender_name: one.senderName,
             text: one.text,
         })),
+        untrusted: hit.email ? [...MESSAGE_HIT_UNTRUSTED, ...MAIL_HIT_UNTRUSTED] : MESSAGE_HIT_UNTRUSTED,
     });
 };
 const accountName = ({ provider, account }) => `${provider}:${account}`;
@@ -160,6 +171,7 @@ const pictureItems = (found) => {
         sender_name: senderName,
         matched_in: "picture",
         score,
+        untrusted: ["sender_name"],
     }));
 };
 /** `search messages` and `search mail`, CLI and MCP alike. */
@@ -175,9 +187,21 @@ export const messagesAnswer = (command, found, { limit, page, again }, query = "
         meta: metaOf(accounts, found.skipped),
     });
 };
-export const noteHitItem = (hit) => defined({ ...hit });
-/** An event's title and the text its excerpt is cut from come from whoever sent the invitation. */
-const EVENT_HIT_UNTRUSTED = ["title", "excerpt"];
+/**
+ * A document comes from a shared drive, where others write and edit; a note is the owner's own, in a folder of
+ * theirs or written in memo, so it is left unmarked.
+ */
+const DOCUMENT_HIT_UNTRUSTED = ["title", "excerpt"];
+export const noteHitItem = (hit) => defined({ ...hit, untrusted: hit.kind === "document" ? DOCUMENT_HIT_UNTRUSTED : undefined });
+/** The text of each kind of `search all` hit that someone other than the owner may have written. */
+const ALL_HIT_UNTRUSTED = {
+    message: ["title", "excerpt", "sender_name"],
+    mail: ["title", "excerpt", "sender_name"],
+    document: DOCUMENT_HIT_UNTRUSTED,
+    note: undefined,
+    event: ["title", "excerpt"],
+    meeting: ["title", "excerpt"],
+};
 export const allHitItem = (item) => item.kind === "meeting"
     ? {
         kind: "meeting",
@@ -190,6 +214,7 @@ export const allHitItem = (item) => item.kind === "meeting"
         offset_ms: item.startMs,
         scope: item.scope,
         id: String(item.id),
+        untrusted: ALL_HIT_UNTRUSTED.meeting,
     }
     : defined({
         kind: item.kind,
@@ -203,7 +228,7 @@ export const allHitItem = (item) => item.kind === "meeting"
         sender_name: item.from?.name,
         sender_ref: item.from?.ref,
         found_by: item.foundBy,
-        untrusted: item.kind === "event" ? EVENT_HIT_UNTRUSTED : undefined,
+        untrusted: ALL_HIT_UNTRUSTED[item.kind],
     });
 /** Meaning was not searched because the model is not downloaded; `--exact` leaving it out is no gap. */
 const meaningGap = (skipped, exact) => skipped === undefined || exact

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

@@ -20,7 +20,7 @@ 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 { itemOf, renderAnswer, snakeKeys } from "./envelope.js";
-import { byteCount, DEFAULT_COMMAND_MS, DEFAULT_OUTPUT_BYTES, execution } from "./execution.js";
+import { byteCount, DEFAULT_AGENT_COOPERATIVE_MS, DEFAULT_COMMAND_MS, DEFAULT_COOPERATIVE_MS, DEFAULT_OUTPUT_BYTES, execution, } from "./execution.js";
 import { setupAtStart } from "./first-run.js";
 import { installHelp } from "./help/first-screen.js";
 import { showInputFields } from "./input-fields.js";
@@ -150,6 +150,11 @@ const runOnce = async (argv, definition, options) => {
     let oneShot;
     // Headless, an interactive command's 5 minutes are for its phase; a person at a terminal may still be answering.
     let afterPhase;
+    let running;
+    const startDeadline = (ms) => {
+        running = ms === undefined ? undefined : { endsAt: Date.now() + ms, ms };
+        control.start(ms);
+    };
     let finished = false;
     // The steps after a phase are one-shot again, however it ended: bounded, and ended by a signal as any command is.
     const endPhase = () => {
@@ -161,7 +166,7 @@ const runOnce = async (argv, definition, options) => {
         // A later phase keeps the --timeout the steps after this one got, not the one this phase already used up.
         if (explicitEnd !== undefined && oneShot !== undefined)
             explicitEnd = Date.now() + oneShot;
-        control.start(afterPhase);
+        startDeadline(afterPhase);
     };
     const interrupted = (signal) => {
         // A second signal ends the command as any signal does: one that ignores its phase can still be stopped.
@@ -234,7 +239,7 @@ const runOnce = async (argv, definition, options) => {
             phased = true;
             phase = new AbortController();
             phase.signal.addEventListener("abort", endPhase, { once: true });
-            control.start(undefined);
+            startDeadline(undefined);
             if (explicitEnd !== undefined)
                 phaseTimer = setTimeout(() => phase.abort(new CliError("timeout", "the command reached its --timeout", {
                     retryable: false,
@@ -243,6 +248,7 @@ const runOnce = async (argv, definition, options) => {
             return phase.signal;
         },
         endUntilStopped: endPhase,
+        deadline: () => running,
     };
     provide(program, environment);
     program.hook("preAction", async (_root, action) => {
@@ -330,7 +336,11 @@ const runOnce = async (argv, definition, options) => {
                 ? undefined
                 : lifetime === "interactive"
                     ? HEADLESS_INTERACTIVE_MS
-                    : DEFAULT_COMMAND_MS
+                    : stopsAtItsPace === true
+                        ? options.agent
+                            ? DEFAULT_AGENT_COOPERATIVE_MS
+                            : DEFAULT_COOPERATIVE_MS
+                        : DEFAULT_COMMAND_MS
             : persistent
                 ? undefined
                 : parseDuration(timeout, flags.timeout === undefined ? envName(definition.app, "TIMEOUT") : "--timeout");
@@ -372,7 +382,7 @@ const runOnce = async (argv, definition, options) => {
             });
             throw new Relayed(code);
         }
-        control.start(deadline);
+        startDeadline(deadline);
         oneShot = deadline;
         afterPhase = timeout !== undefined || persistent || job || interactiveLogin ? deadline : DEFAULT_COMMAND_MS;
         if (timeout !== undefined && deadline !== undefined)

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

@@ -9,11 +9,16 @@ export interface UpgradeContext extends Omit<PackageUpgradePorts, "onInstall"> {
 }
 /**
  * A running serve keeps the code it started with; the update replaced the files under it. Each is restarted by
- * the new `script` — `server restart` refuses a serve started by hand, which is then named in `left`.
- * `spawn` replaces the child process, as in `UpdateEnvironment`.
+ * the new `script` — `server restart` refuses a serve started by hand, which is then named in `left`, and one that
+ * ran out of time is named in `timedOut` too. `spawn` replaces the child process, as in `UpdateEnvironment`.
  */
 export declare const restartServers: (app: AppIdentity, script: string, env: NodeJS.ProcessEnv, spawn?: (argv: string[]) => number) => {
     restarted: string[];
     left: string[];
+    timedOut: string[];
+} | {
+    timedOut?: undefined;
+    restarted: string[];
+    left: string[];
 };
 export declare const upgradeCommand: (app: AppIdentity, packageName: string, contextFor: (command: Command) => UpgradeContext) => Command;

package/dist/cli/upgrade-command.js

@@ -2,19 +2,25 @@ import { spawnSync } from "node:child_process";
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
+import { restartMcpServers, staleMcpSessions, thisSystem, } from "../background/after-upgrade.js";
 import { servingProfiles } from "../background/lock.js";
-import { upgradePackage } from "../services/package-upgrade.js";
+import { upgradePackage, } from "../services/package-upgrade.js";
+import { environmentOf } from "./context.js";
 import { grantsAuthority, LOCAL_WRITE } from "./effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "./envelope.js";
 import { usableProfileName } from "./profile.js";
+/** `server restart` waits 30 s for serve to stop and 30 s for it to listen; this is a ceiling over both. */
+const RESTART_CEILING_MS = 90_000;
+const TIMEOUT_EXIT = 9;
 /**
  * A running serve keeps the code it started with; the update replaced the files under it. Each is restarted by
- * the new `script` — `server restart` refuses a serve started by hand, which is then named in `left`.
- * `spawn` replaces the child process, as in `UpdateEnvironment`.
+ * the new `script` — `server restart` refuses a serve started by hand, which is then named in `left`, and one that
+ * ran out of time is named in `timedOut` too. `spawn` replaces the child process, as in `UpdateEnvironment`.
  */
 export const restartServers = (app, script, env, spawn) => {
     const restarted = [];
     const left = [];
+    const timedOut = [];
     for (const profile of servingProfiles(app, env)) {
         try {
             usableProfileName(profile);
@@ -25,11 +31,40 @@ export const restartServers = (app, script, env, spawn) => {
         const argv = [script, profile, "server", "restart"];
         const code = spawn
             ? spawn([process.execPath, ...argv])
-            : (spawnSync(process.execPath, argv, { env, shell: false, stdio: ["ignore", 2, 2] }).status ?? 1);
+            : (spawnSync(process.execPath, argv, {
+                env,
+                shell: false,
+                stdio: ["ignore", 2, 2],
+                timeout: RESTART_CEILING_MS,
+            }).status ?? TIMEOUT_EXIT);
         (code === 0 ? restarted : left).push(profile);
+        if (code === TIMEOUT_EXIT)
+            timedOut.push(profile);
     }
-    return { restarted, left };
+    return timedOut.length > 0 ? { restarted, left, timedOut } : { restarted, left };
 };
+const RESTART_FROM_APP = "restart them from your agent app (start a new chat, or reload its MCP servers)";
+const mcpWarnings = (command, current, servers, stale) => [
+    ...servers.flatMap((server) => !server.restarted
+        ? [`the HTTP MCP server ${server.name} (PID ${server.pid}) was not restarted: ${server.reason}`]
+        : server.to !== null && server.to === server.from
+            ? [
+                `the HTTP MCP server ${server.name} came back on ${command} ${server.to}: it runs from another install than the one upgraded`,
+            ]
+            : []),
+    ...(stale === undefined
+        ? []
+        : !stale.checked
+            ? [
+                `could not check for MCP sessions over stdio (${stale.reason}); any that run keep ${command} ${current} or older — ${RESTART_FROM_APP}`,
+            ]
+            : stale.sessions.length > 0
+                ? [
+                    `${stale.sessions.length} MCP ${stale.sessions.length === 1 ? "session" : "sessions"} over stdio still ${stale.sessions.length === 1 ? "runs" : "run"} ${command} ${current} or older ` +
+                        `(PID ${stale.sessions.map((session) => session.pid).join(", ")}) — ${RESTART_FROM_APP}`,
+                ]
+                : []),
+];
 export const upgradeCommand = (app, packageName, contextFor) => grantsAuthority(annotate(new Command("upgrade"), {
     effects: LOCAL_WRITE,
     offline: false,
@@ -42,7 +77,19 @@ export const upgradeCommand = (app, packageName, contextFor) => grantsAuthority(
         throw new CliError("validation_error", `\`${app.command} upgrade\` asks npm for the newest version; not with --offline`);
     const context = contextFor(this);
     const { renderer } = context;
-    const { result, reason, left } = await upgradePackage({ current: app.version, command: app.command, packageName, check: check === true }, { ...context, onInstall: (argv) => renderer.note(`running: ${argv.join(" ")}`) });
+    const environment = environmentOf(this);
+    const env = environment.env ?? process.env;
+    // Built before the install: after it, the old process may no longer find its own lazily loaded files.
+    const system = { ...thisSystem(packageName, app.command), ...environment.afterUpgrade };
+    const afterUpdate = async () => {
+        const servers = (await context.afterUpdate?.()) ?? { restarted: [], left: [] };
+        return {
+            ...servers,
+            mcpServers: await restartMcpServers(app, env, system),
+            staleSessions: staleMcpSessions(system),
+        };
+    };
+    const { result, reason, left, timedOut } = await upgradePackage({ current: app.version, command: app.command, packageName, check: check === true }, { ...context, afterUpdate, onInstall: (argv) => renderer.note(`running: ${argv.join(" ")}`) });
     if (reason === "held_back" && result.heldBack)
         renderer.warn(heldBackAdvice(result, result.heldBack));
     if (reason === "unavailable")
@@ -58,9 +105,14 @@ export const upgradeCommand = (app, packageName, contextFor) => grantsAuthority(
         renderer.warn(advice);
     }
     for (const profile of left) {
-        renderer.warn(`the server for profile ${profile} still runs ${app.command} ${app.version} — ` +
-            `\`${app.command} ${profile} server restart\``);
+        renderer.warn(timedOut?.includes(profile)
+            ? `the server for profile ${profile} did not restart in time and may still run ${app.command} ${app.version} — ` +
+                `\`${app.command} ${profile} server status\``
+            : `the server for profile ${profile} still runs ${app.command} ${app.version} — ` +
+                `\`${app.command} ${profile} server restart\``);
     }
+    for (const line of mcpWarnings(app.command, app.version, result.mcpServers ?? [], result.staleSessions))
+        renderer.warn(line);
     renderAnswer(this, context, itemOf(snakeKeys(result)), () => summary(app.command, result));
 });
 const heldBackAdvice = ({ installed, latest, installer }, { until, command }) => {
@@ -75,7 +127,11 @@ const summary = (command, result) => {
         const servers = result.restarted.length > 0
             ? `; restarted the server for ${result.restarted.map((profile) => `profile ${profile}`).join(", ")}`
             : "";
-        return `${command} ${result.current} → ${result.installed ?? result.latest}${held}${servers}`;
+        const mcp = (result.mcpServers ?? []).filter((server) => server.restarted);
+        const http = mcp.length > 0
+            ? `; restarted the HTTP MCP server ${mcp.map((server) => `${server.name} (${server.from ?? "?"} → ${server.to ?? "?"})`).join(", ")}`
+            : "";
+        return `${command} ${result.current} → ${result.installed ?? result.latest}${held}${servers}${http}`;
     }
     if (held)
         return `${command} ${result.current}${held}`;

package/dist/entities/fields.d.ts

@@ -7,6 +7,8 @@ export declare const time: v.SchemaWithPipe<readonly [v.StringSchema<undefined>,
 /** A time a caller sends: any offset, read as the moment it names. Answers carry `time`, always UTC. */
 export declare const zonedTime: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time with a zone">]>;
 export declare const count: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+/** Fields of an answer item someone other than the owner wrote, as dotted paths: an agent reads them as data. */
+export declare const untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
 export declare const providerMetadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
 export declare const author: v.StrictObjectSchema<{
     readonly type: v.PicklistSchema<["person", "bot"], undefined>;

package/dist/entities/fields.js

@@ -7,6 +7,8 @@ export const time = isoTime;
 /** A time a caller sends: any offset, read as the moment it names. Answers carry `time`, always UTC. */
 export const zonedTime = v.pipe(v.string(), v.isoTimestamp("an ISO 8601 time with a zone"));
 export const count = v.pipe(v.number(), v.integer(), v.minValue(0));
+/** Fields of an answer item someone other than the owner wrote, as dotted paths: an agent reads them as data. */
+export const untrusted = v.optional(v.array(text));
 export const providerMetadata = v.optional(v.record(v.string(), v.unknown()));
 export const author = v.strictObject({
     type: v.picklist(["person", "bot"]),

package/dist/entities/hit.d.ts

@@ -22,6 +22,6 @@ export declare const hit: v.StrictObjectSchema<{
     readonly scope: v.OptionalSchema<v.PicklistSchema<["transcript", "chat", "summary"], undefined>, undefined>;
     /** A meeting passage's stored line, so two passages of one meeting stay apart; `search meetings` gives the same. */
     readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
-    /** An event hit's fields that whoever sent the invitation wrote: an agent reads them as data. */
+    /** Absent on a note hit: the owner wrote it. */
     readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
 }, undefined>;

package/dist/entities/hit.js

@@ -1,5 +1,5 @@
 import * as v from "valibot";
-import { count, reference, text, time } from "./fields.js";
+import { count, reference, text, time, untrusted } from "./fields.js";
 /** One result of `search all`: a message, a mail, a note, a calendar event or a meeting passage, best first. */
 export const hit = v.strictObject({
     kind: v.picklist(["message", "mail", "note", "document", "event", "meeting"]),
@@ -23,6 +23,6 @@ export const hit = v.strictObject({
     scope: v.optional(v.picklist(["transcript", "chat", "summary"])),
     /** A meeting passage's stored line, so two passages of one meeting stay apart; `search meetings` gives the same. */
     id: v.optional(v.pipe(v.string(), v.minLength(1))),
-    /** An event hit's fields that whoever sent the invitation wrote: an agent reads them as data. */
-    untrusted: v.optional(v.array(text)),
+    /** Absent on a note hit: the owner wrote it. */
+    untrusted,
 });