@wirecat/cli-core 0.406.0 → 0.408.0

package/CHANGELOG.md

@@ -5,6 +5,30 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
+## 0.408.0 — 24.10.2026
+
+### Fixed
+
+- **MCP discovery retains permission-denied commands.** Full listings and searches return each command's
+  current `availability`, including a reason and permission key when blocked. With a named profile,
+  CLI help and command discovery also show current availability without hiding commands. Read-only profiles and process
+  locks keep writing commands discoverable. Calls still recheck permissions and refuse before execution;
+  seeing a command does not grant access. Bot MCP also lists bot-scoped `config show|set|unset` behind the
+  existing authority rules, without exposing options that could select personal-account settings. Consumers
+  that pin MCP catalogues should refresh them and use availability rather than absence to determine access.
+
+## 0.407.0 — 24.10.2026
+
+### Added
+
+- The `contact` entity has optional `email` and `phones` (number and label), for a source that knows them, such as zm's Zoom contacts.
+
+- Command discovery projections preserve the CLI document and command identities while selecting fields inside its command tree.
+
+- Portable ingestion, export, association, transcription and embedding receipts have shared entities and `meetingResultItem` serializers. Public IDs are strings; stored numeric IDs remain internal.
+
+- Meeting batch results declare their correlated success/error schemas. `answerEntity` can name a separate typed projection payload, preserving batch field selection inside each answer without weakening its outer result contract.
+
 ## 0.406.0 — 24.10.2026
 
 ### Added

package/dist/cli/answer-entity.d.ts

@@ -1,5 +1,8 @@
 import type { Command } from "commander";
 import type * as v from "valibot";
 /** Provider-specific wire fields must not redefine an entity shared by every CLI. */
-export declare const answerEntity: (command: Command, name: string, schema: v.GenericSchema) => Command;
+export declare const answerEntity: (command: Command, name: string, schema: v.GenericSchema, options?: {
+    project?: v.GenericSchema;
+}) => Command;
 export declare const answerEntitySchema: (command: Command | undefined) => v.GenericSchema | undefined;
+export declare const answerProjectionSchema: (command: Command | undefined) => v.GenericSchema | undefined;

package/dist/cli/answer-entity.js

@@ -2,14 +2,16 @@ import { annotate, metaOf } from "@wirecat/cli-base/commands";
 import { ENTITIES } from "../entities/index.js";
 const schemas = new WeakMap();
 /** Provider-specific wire fields must not redefine an entity shared by every CLI. */
-export const answerEntity = (command, name, schema) => {
+export const answerEntity = (command, name, schema, options = {}) => {
     if (Object.hasOwn(ENTITIES, name))
         throw new Error(`${name} is a shared entity; use its existing schema`);
     if (!/^[a-z][a-z0-9_]*$/.test(name))
         throw new Error("an answer entity needs a lowercase name");
     if (!("entries" in schema) && schema.type !== "union")
         throw new Error("an answer entity needs an object schema or a union of object schemas");
-    schemas.set(command, { name, schema });
+    if (options.project && !("entries" in options.project) && options.project.type !== "union")
+        throw new Error("projection needs an object schema or a union of object schemas");
+    schemas.set(command, { name, schema, ...options });
     return annotate(command, { output: { entity: name } });
 };
 export const answerEntitySchema = (command) => {
@@ -23,3 +25,7 @@ export const answerEntitySchema = (command) => {
     const own = schemas.get(command);
     return own?.name === name ? own.schema : undefined;
 };
+export const answerProjectionSchema = (command) => {
+    const own = command && schemas.get(command);
+    return own && metaOf(command).output?.entity === own.name ? own.project : undefined;
+};

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

@@ -0,0 +1,14 @@
+import type { CommandInfo } from "@wirecat/cli-base/commands";
+import { type Level, type PermissionKey } from "../sends/permissions.js";
+export type AvailabilityCommand = Pick<CommandInfo, "path" | "effects" | "lifetime" | "reaches">;
+export interface DiscoveredCommand extends CommandInfo {
+    availability?: CommandAvailability;
+    commands: readonly DiscoveredCommand[];
+}
+export interface CommandAvailability {
+    available: boolean;
+    reason?: string;
+    permission?: string;
+}
+/** Discovery and execution use the same permission decision. */
+export declare const commandAvailability: (info: AvailabilityCommand, levels: Readonly<Record<PermissionKey, Level>>, keyOf?: (path: readonly string[]) => PermissionKey | null | undefined, authority?: (path: readonly string[]) => boolean, readOnly?: boolean, mcp?: boolean) => CommandAvailability;

package/dist/cli/command-availability.js

@@ -0,0 +1,25 @@
+import { writes } from "@wirecat/cli-base/standards";
+import { AUTHORITY_KEY, authorityAllowed, BOT_API_KEY, botApiAllowed, isBotApi, keyForCommand, levelFor, readKeysForCommand, } from "../sends/permissions.js";
+import { changesMessenger } from "./effects.js";
+/** Discovery and execution use the same permission decision. */
+export const commandAvailability = (info, levels, keyOf, authority, readOnly = false, mcp = true) => {
+    const blocked = (reason, permission) => ({
+        available: false,
+        reason,
+        ...(permission ? { permission } : {}),
+    });
+    if (readOnly && (changesMessenger(info) || authority?.(info.path)))
+        return blocked("the read-only lock blocks this change");
+    if (mcp && authority?.(info.path) && !authorityAllowed(levels))
+        return blocked(`the profile keeps ${AUTHORITY_KEY} off`, AUTHORITY_KEY);
+    if (mcp && isBotApi(info.path) && !botApiAllowed(levels))
+        return blocked(`the profile requires ${BOT_API_KEY}: allow`, BOT_API_KEY);
+    const key = keyOf?.(info.path) ?? keyForCommand(info.path);
+    const level = key ? levelFor(levels, key).level : "allow";
+    if (level === "deny")
+        return blocked(`the profile denies ${key}`, key ?? undefined);
+    if (level === "readonly" && writes(info.effects))
+        return blocked(`${key} is readonly in this profile`, key ?? undefined);
+    const denied = readKeysForCommand(info.path).find((read) => levelFor(levels, read).level === "deny");
+    return denied ? blocked(`the profile denies ${denied}`, denied) : { available: true };
+};

package/dist/cli/command-contract.js

@@ -2,7 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { describeOptions, metaOf } from "@wirecat/cli-base/commands";
 import { jsonSchemaOf } from "@wirecat/cli-base/standards";
 import { keyForCommand } from "../sends/permissions.js";
-import { answerEntitySchema } from "./answer-entity.js";
+import { answerEntitySchema, answerProjectionSchema } from "./answer-entity.js";
 import { answerSchema } from "./envelope.js";
 export const SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
 /**
@@ -97,7 +97,9 @@ export const commandContract = (command) => {
         outputSchemaCoverage: output.coverage,
         jsonlSchema: { $schema: SCHEMA_DIALECT, ...output.item },
         jsonlSchemaCoverage: output.coverage,
-        projection: "--json=<fields> may omit item/object members; present members retain their types and envelopes are preserved",
+        projection: answerProjectionSchema(command)
+            ? "--json=<fields> selects inside each nested answer; correlation and envelopes are preserved"
+            : "--json=<fields> may omit item/object members; present members retain their types and envelopes are preserved",
         validation: {
             syntax: "declared",
             semantic: "command-and-provider-validation",

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

@@ -7,6 +7,6 @@ import type { AppIdentity } from "../ports/app.js";
 export declare const CONTRACT = 3;
 /**
  * The discovery surface an agent reads instead of `--help`. It opens no store, no session and no
- * settings file: which commands exist does not depend on whether this machine has logged in.
+ * settings file without a named profile. A named profile adds availability without hiding commands.
  */
 export declare const commandsCommand: (app: AppIdentity) => Command;

package/dist/cli/commands-command.js

@@ -1,8 +1,8 @@
 import { CliError, EXIT_CODES, GENERIC_FAILURE } from "@wirecat/cli-base";
-import { annotate, describeOptions, describeProgram } from "@wirecat/cli-base/commands";
+import { annotate, describeOptions, describeProgram, metaOf } from "@wirecat/cli-base/commands";
 import { CRASH_CODE } from "@wirecat/cli-base/standards";
 import { Command } from "commander";
-import { commandContract, findCommand } from "./command-contract.js";
+import { commandContract, commandPathOf, findCommand } from "./command-contract.js";
 import { environmentOf, outputFor } from "./context.js";
 import { NO_EFFECTS } from "./effects.js";
 import { renderDocument } from "./envelope.js";
@@ -15,7 +15,7 @@ import { rootOf } from "./profile.js";
 export const CONTRACT = 3;
 /**
  * The discovery surface an agent reads instead of `--help`. It opens no store, no session and no
- * settings file: which commands exist does not depend on whether this machine has logged in.
+ * settings file without a named profile. A named profile adds availability without hiding commands.
  */
 export const commandsCommand = (app) => {
     const command = annotate(new Command("commands"), { effects: NO_EFFECTS })
@@ -30,7 +30,12 @@ export const commandsCommand = (app) => {
         .action(function (path) {
         const root = rootOf(this);
         const output = outputFor(this);
-        const all = describeProgram(root);
+        const available = environmentOf(this).discoveryAvailability;
+        const annotateAvailability = (infos) => infos.map((info) => {
+            const availability = available?.(info);
+            return { ...info, ...(availability ? { availability } : {}), commands: annotateAvailability(info.commands) };
+        });
+        const all = annotateAvailability(describeProgram(root));
         const scoped = path.length > 0 ? scopeOf(root, all, path) : undefined;
         const commands = scoped ? [scoped.command] : all;
         const { json, jsonl } = this.optsWithGlobals();
@@ -62,6 +67,14 @@ export const commandsCommand = (app) => {
             version: app.version,
             contract: CONTRACT,
             ...commandContract(findCommand(rootOf(this), path)),
+            ...(() => {
+                const found = findCommand(rootOf(this), path);
+                const availability = environmentOf(this).discoveryAvailability?.({
+                    ...metaOf(found),
+                    path: commandPathOf(found),
+                });
+                return availability ? { availability } : {};
+            })(),
         });
     }));
     return command;

package/dist/cli/context.d.ts

@@ -11,6 +11,7 @@ import { type Closeable } from "./deadline.js";
 import type { GlobalFlags, ResolveOptions, Settings } from "./settings.js";
 /** What every CLI's commands write to, when it is not the real terminal. A CLI adds its own fields. */
 export interface BaseEnvironment {
+    discoveryAvailability?: (command: import("./command-availability.js").AvailabilityCommand) => import("./command-availability.js").CommandAvailability | undefined;
     streams?: Streams;
     /** Whether a person is looking. Defaults to whether stdout is a terminal. */
     tty?: boolean;

package/dist/cli/effects.d.ts

@@ -14,7 +14,7 @@ export declare const NO_EFFECTS: Effects;
 /**
  * Marks a local write that changes what a later run may do: a schedule, a setting, the recipient list, an
  * auto-reply, an agent's setup. `<PREFIX>_READ_ONLY` refuses it, or an agent under the lock could hand an
- * unlocked run the send it may not make itself (SEC-47). For the same reason an MCP server offers it only where the
+ * unlocked run the send it may not make itself (SEC-47). For the same reason an MCP server permits execution only where the
  * profile allows `mcp.authority`, which is off until the owner turns it on (NEED-1662).
  * `unless` names a flag that makes the run only look (`upgrade --check`), which the lock lets through.
  */

package/dist/cli/effects.js

@@ -16,7 +16,7 @@ const AUTHORITY = new WeakMap();
 /**
  * Marks a local write that changes what a later run may do: a schedule, a setting, the recipient list, an
  * auto-reply, an agent's setup. `<PREFIX>_READ_ONLY` refuses it, or an agent under the lock could hand an
- * unlocked run the send it may not make itself (SEC-47). For the same reason an MCP server offers it only where the
+ * unlocked run the send it may not make itself (SEC-47). For the same reason an MCP server permits execution only where the
  * profile allows `mcp.authority`, which is off until the owner turns it on (NEED-1662).
  * `unless` names a flag that makes the run only look (`upgrade --check`), which the lock lets through.
  */

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

@@ -1,6 +1,7 @@
 import { metaOf } from "@wirecat/cli-base/commands";
 import { writes } from "@wirecat/cli-base/standards";
 import { commandPathOf, outputOf } from "../command-contract.js";
+import { environmentOf } from "../context.js";
 import { PROFILE_FREE } from "../profile.js";
 import { commandAt } from "../steps.js";
 import { short } from "./commands-text.js";
@@ -195,7 +196,23 @@ const LABEL = 15;
 export const commandHelpText = (command) => {
     const { returns, next, examples } = commandHelp(command);
     const rows = (label, values) => values.map((value, at) => `${(at === 0 ? label : "").padEnd(LABEL)}${value}`);
-    return ["", ...rows("Returns:", [returns]), ...rows("Next usually:", next), ...rows("Example:", examples), ""].join("\n");
+    const availability = environmentOf(command).discoveryAvailability?.({
+        ...metaOf(command),
+        path: commandPathOf(command),
+    });
+    const access = availability
+        ? rows("Availability:", [
+            availability.available ? "available for this profile" : `unavailable — ${availability.reason}`,
+        ])
+        : [];
+    return [
+        "",
+        ...access,
+        ...rows("Returns:", [returns]),
+        ...rows("Next usually:", next),
+        ...rows("Example:", examples),
+        "",
+    ].join("\n");
 };
 /** The same, as Markdown lines for `docs/commands.md`: hand it to cli-base's `commandsPage` per command. */
 export const commandHelpMarkdown = (root, path) => {

package/dist/cli/help/commands-text.d.ts

@@ -1,5 +1,5 @@
-import type { CommandInfo } from "@wirecat/cli-base/commands";
 import type { Command } from "commander";
+import type { DiscoveredCommand as CommandInfo } from "../command-availability.js";
 /** The first clause that fits: a line per command is the point, the whole text is in `--help`. */
 export declare const short: (text: string) => string;
 /**

package/dist/cli/help/commands-text.js

@@ -33,10 +33,11 @@ export const commandsText = (root, commands, scope) => {
         if (infos.length === 0)
             continue;
         lines.push("", SECTIONS[section]);
-        for (const { usage, summary, description, effects } of infos) {
+        for (const { usage, summary, description, effects, availability } of infos) {
             const what = short(summary ?? description);
             const mark = effects === undefined || writes(effects) ? " (writes)" : "";
-            lines.push(`  ${usage.padEnd(COLUMN)}  ${what}${mark}`.trimEnd());
+            const access = availability?.available === false ? ` [unavailable: ${availability.reason}]` : "";
+            lines.push(`  ${usage.padEnd(COLUMN)}  ${what}${mark}${access}`.trimEnd());
         }
     }
     return `${lines.join("\n")}\n`;

package/dist/cli/index.d.ts

@@ -1,5 +1,6 @@
 export { AI_ENTRIES, AI_SETTING_KEYS, type AISettings, resolveAISettings } from "../analysis/settings.js";
 export { parseDuration } from "../domain/duration.js";
+export { syncProgress } from "../entities/store-records.js";
 export { isCliFailure, isCommanderFailure } from "../errors/failures.js";
 export { type AppErrors, failureContext } from "../errors/reasons.js";
 export { botInstructions } from "../mcp/bot/instructions.js";
@@ -10,6 +11,7 @@ export { callMeetingProjectCandidatesTool, meetingProjectCandidatesTool } from "
 export { callMeetingSeriesInventoryTool, meetingSeriesInventoryTool } from "../mcp/meeting-series-inventory.js";
 export { registerLinkConversationsPrompt } from "../mcp/prompts.js";
 export { agentBody, agentJson, agentResult, UNTRUSTED, UNTRUSTED_INSTRUCTION } from "../mcp/text.js";
+export { MEETING_RESULT_ENTITIES } from "../meetings/index.js";
 export { type AppIdentity, envName, readOnlyLockOf, readOnlyRefusal } from "../ports/app.js";
 export type { AccountEditing, AccountHealth, AccountRecords, AccountSettings, AccountStanding, AccountTools, After, BotChats, ChannelComments, ChatDeletion, ChatFolders, ChatReading, ContactBook, Download, ForumControl, ForumState, GroupAdmin, GroupModeration, HistoryBatch, HistoryChatEvent, HistoryReaction, HistoryStar, HistoryVote, InviteLinks, JoinRequests, LiveUpdates, MessageButtons, MessageEditing, MessageMedia, MessagePermalinks, MessagePins, MessagePolls, MessageReactions, MessageSearch, MessageStars, MessengerAdapter, MessengerCore, NewPoll, OfficialStats, PassiveUpdates, PersonProfiles, ProfileChange, ProfilePhotos, PushedHistory, ReadState, RemoteFile, ScheduledMessages, SenderIdentities, SenderSearch, SendOptions, Sent, ServerQuery, ServerReads, ThreadAddressing, TopicEditing, TopicHistory, TopicReadState, Transcript, } from "../ports/messenger.js";
 export type { Fetching, MediaOption, MessengerTraits } from "../ports/traits.js";
@@ -47,6 +49,7 @@ export { BOT_ACTIONS, type BotAction, type BotAdapter, type BotCallbacks, type B
 export { botFiles, botsDirectory, ChatRegistry, registryProfiles, type SeenChat } from "./bot/registry.js";
 export { BotTokenStore, type BotTokenStoreOptions } from "./bot/token.js";
 export { PressLog, UpdatesCursor } from "./bot/updates.js";
+export type { CommandAvailability, DiscoveredCommand } from "./command-availability.js";
 export { commandContract, type JsonSchema, SCHEMA_DIALECT } from "./command-contract.js";
 export { CONTRACT, commandsCommand } from "./commands-command.js";
 export { configCommand, refuseUnknownKey } from "./config-command.js";
@@ -54,8 +57,8 @@ export { loadSnakeCaseConfig } from "./config-keys.js";
 export { type AgentRun, type BaseContext, type BaseEnvironment, baseContext, environmentOf, outputFor, provide, secretInputOf, } from "./context.js";
 export { type Closeable, withDeadline } from "./deadline.js";
 export { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
-export { changesAuthority, changesAuthorityAt, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, } from "./effects.js";
-export { type AnswerOutput, answerSchema, type Body, type ItemBody, itemAnswer, itemOf, jsonlRecords, judgedAnswer, type ListBody, type ListInput, listOf, metaNow, printItem, renderAnswer, sealed, snakeKeys, snakeKeysKeeping, } from "./envelope.js";
+export { changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, } from "./effects.js";
+export { type AnswerOutput, answerSchema, type Body, type ItemBody, isBody, itemAnswer, itemOf, jsonlRecords, judgedAnswer, type ListBody, type ListInput, listOf, metaNow, printItem, renderAnswer, sealed, snakeKeys, snakeKeysKeeping, } from "./envelope.js";
 export { withAbort } from "./execution.js";
 export { askSetupQuestions, asksAtStart, type FirstRun, type FirstRunIo, LANGUAGES, setupAtStart, systemLanguage, } from "./first-run.js";
 export { checkGuide, checkStep, type GuideOptions, type GuideReference, type GuideStep, guideCommand, loadScenarios, MEMO_SCENARIOS, type Scenario, shellProblems, } from "./guide.js";
@@ -74,6 +77,7 @@ export { addMeetingPreparationCommand } from "./meeting-preparation-command.js";
 export { type MeetingPreparationReader, meetingPreparationInput, readMeetingPreparation, } from "./meeting-preparation-read.js";
 export { addMeetingProjectCandidatesCommand } from "./meeting-project-candidates-command.js";
 export { readMeetingProjectCandidates } from "./meeting-project-candidates-read.js";
+export { meetingResultItem } from "./meeting-results.js";
 export { addMeetingSeriesInventoryCommand } from "./meeting-series-inventory-command.js";
 export { type MeetingSeriesInventoryReader, readMeetingSeriesInventory } from "./meeting-series-inventory-read.js";
 export { accountCommand } from "./messenger/account-command.js";

package/dist/cli/index.js

@@ -1,5 +1,6 @@
 export { AI_ENTRIES, AI_SETTING_KEYS, resolveAISettings } from "../analysis/settings.js";
 export { parseDuration } from "../domain/duration.js";
+export { syncProgress } from "../entities/store-records.js";
 export { isCliFailure, isCommanderFailure } from "../errors/failures.js";
 export { failureContext } from "../errors/reasons.js";
 export { botInstructions } from "../mcp/bot/instructions.js";
@@ -8,6 +9,7 @@ export { callMeetingProjectCandidatesTool, meetingProjectCandidatesTool } from "
 export { callMeetingSeriesInventoryTool, meetingSeriesInventoryTool } from "../mcp/meeting-series-inventory.js";
 export { registerLinkConversationsPrompt } from "../mcp/prompts.js";
 export { agentBody, agentJson, agentResult, UNTRUSTED, UNTRUSTED_INSTRUCTION } from "../mcp/text.js";
+export { MEETING_RESULT_ENTITIES } from "../meetings/index.js";
 export { envName, readOnlyLockOf, readOnlyRefusal } from "../ports/app.js";
 export { senderFacts } from "../replies/dry-run.js";
 export { replyRenderer } from "../replies/rendering.js";
@@ -49,8 +51,8 @@ export { loadSnakeCaseConfig } from "./config-keys.js";
 export { baseContext, environmentOf, outputFor, provide, secretInputOf, } from "./context.js";
 export { withDeadline } from "./deadline.js";
 export { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
-export { changesAuthority, changesAuthorityAt, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, } from "./effects.js";
-export { answerSchema, itemAnswer, itemOf, jsonlRecords, judgedAnswer, listOf, metaNow, printItem, renderAnswer, sealed, snakeKeys, snakeKeysKeeping, } from "./envelope.js";
+export { changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, } from "./effects.js";
+export { answerSchema, isBody, itemAnswer, itemOf, jsonlRecords, judgedAnswer, listOf, metaNow, printItem, renderAnswer, sealed, snakeKeys, snakeKeysKeeping, } from "./envelope.js";
 export { withAbort } from "./execution.js";
 export { askSetupQuestions, asksAtStart, LANGUAGES, setupAtStart, systemLanguage, } from "./first-run.js";
 export { checkGuide, checkStep, guideCommand, loadScenarios, MEMO_SCENARIOS, shellProblems, } from "./guide.js";
@@ -69,6 +71,7 @@ export { addMeetingPreparationCommand } from "./meeting-preparation-command.js";
 export { meetingPreparationInput, readMeetingPreparation, } from "./meeting-preparation-read.js";
 export { addMeetingProjectCandidatesCommand } from "./meeting-project-candidates-command.js";
 export { readMeetingProjectCandidates } from "./meeting-project-candidates-read.js";
+export { meetingResultItem } from "./meeting-results.js";
 export { addMeetingSeriesInventoryCommand } from "./meeting-series-inventory-command.js";
 export { readMeetingSeriesInventory } from "./meeting-series-inventory-read.js";
 export { accountCommand } from "./messenger/account-command.js";

package/dist/cli/json-fields.js

@@ -1,7 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { metaOf } from "@wirecat/cli-base/commands";
 import { ENTITIES } from "../entities/index.js";
-import { answerEntitySchema } from "./answer-entity.js";
+import { answerEntitySchema, answerProjectionSchema } from "./answer-entity.js";
 const declaredEntity = (command) => {
     const output = command ? metaOf(command).output : undefined;
     return output && (output.view ? `${output.entity}.${output.view}` : output.entity);
@@ -38,7 +38,7 @@ export const answerFields = (command, resolve) => {
     const own = resolve?.(command);
     if (own !== undefined)
         return [...own];
-    const schema = answerEntitySchema(command);
+    const schema = answerProjectionSchema(command) ?? answerEntitySchema(command);
     return schemaFields(schema);
 };
 const PATHS = /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*(,[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*)*$/;

package/dist/cli/meeting-batch.d.ts

@@ -1,5 +1,5 @@
 import { type BatchReport } from "@wirecat/cli-base";
-import type { Meta } from "@wirecat/cli-base/standards";
+import { type Meta } from "@wirecat/cli-base/standards";
 import { Command } from "commander";
 import { type MeetingBatchReader, type MeetingPassageOutputFormat } from "../meetings/index.js";
 import { type Body } from "./envelope.js";

package/dist/cli/meeting-batch.js

@@ -1,11 +1,16 @@
 import { BATCH_LIMITS, CliError, prepareBatch, runBatch, } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
+import { errorObjectSchema } from "@wirecat/cli-base/standards";
 import { Command, Option } from "commander";
+import * as v from "valibot";
+import { ENTITIES } from "../entities/index.js";
 import { failureContext } from "../errors/reasons.js";
 import { createMeetingPassageCommand, createMeetingSearchCommand, meetingHitSearchRequest, meetingPassageRequest, meetingSearchArguments, meetingSearchMeta, } from "../meetings/cli/index.js";
 import { meetingHitsList, parseMeetingReference, } from "../meetings/index.js";
 import { formatMeetingEvidenceText, formatMeetingPassage } from "../services/meeting-passage-format.js";
-import { itemOf, listOf } from "./envelope.js";
+import { answerEntity } from "./answer-entity.js";
+import { destroysNothing } from "./effects.js";
+import { answerSchema, itemOf, listOf } from "./envelope.js";
 const INDEX_BYTES = 4194304;
 const parse = (command, args) => {
     command
@@ -162,10 +167,23 @@ export const addMeetingBatchCommand = (program, deps) => {
             },
         }), report, format);
     });
-    return annotate(command, {
+    destroysNothing(command);
+    annotate(command, {
         origin: "handwritten",
         partial: true,
         effects: { remote: "none", local: "write" },
         examples: [`${program.name()} batch requests.json --json`],
     });
+    return answerEntity(command, "meeting_batch_result", batchResult, { project: batchPayload });
 };
+const batchPayload = v.union([ENTITIES.meeting_hit, ENTITIES.meeting_passage]);
+const correlated = { id: v.string(), command: v.array(v.string()) };
+const batchResult = v.union([
+    v.strictObject({ ...correlated, status: v.literal("ok"), answer: answerSchema(batchPayload), complete: v.boolean() }),
+    v.strictObject({
+        ...correlated,
+        status: v.picklist(["error", "not_run"]),
+        error: errorObjectSchema.entries.error,
+        complete: v.literal(false),
+    }),
+]);

package/dist/cli/meeting-results.d.ts

@@ -0,0 +1,3 @@
+import { MEETING_RESULT_ENTITIES } from "../meetings/index.js";
+/** Store IDs stay numeric below the CLI; public receipts use the shared string IDs and validated wire fields. */
+export declare const meetingResultItem: (entity: keyof typeof MEETING_RESULT_ENTITIES, value: unknown) => unknown;

package/dist/cli/meeting-results.js

@@ -0,0 +1,31 @@
+import { CliError } from "@wirecat/cli-base";
+import * as v from "valibot";
+import { MEETING_RESULT_ENTITIES } from "../meetings/index.js";
+import { snakeKeys } from "./envelope.js";
+const ids = new Set([
+    "meeting_id",
+    "account_id",
+    "participant_id",
+    "event_id",
+    "previous_event_id",
+    "expected_event_id",
+    "next_transcript_id",
+]);
+const publicValue = (value, key = "") => {
+    if (typeof value === "number" && ids.has(key))
+        return String(value);
+    if (Array.isArray(value))
+        return value.map((item) => publicValue(item, key === "target_account_ids" ? "account_id" : ""));
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([name, item]) => [name, publicValue(item, name)]));
+    return value;
+};
+/** Store IDs stay numeric below the CLI; public receipts use the shared string IDs and validated wire fields. */
+export const meetingResultItem = (entity, value) => {
+    const parsed = v.safeParse(MEETING_RESULT_ENTITIES[entity], publicValue(snakeKeys(value)));
+    if (!parsed.success) {
+        const applied = value && typeof value === "object" && "applied" in value && value.applied === true;
+        throw new CliError(applied ? "outcome_unknown" : "invalid_response", `the command returned an invalid ${entity} answer`);
+    }
+    return parsed.output;
+};

package/dist/cli/program.d.ts

@@ -9,7 +9,8 @@ export interface ProgramDefinition {
     commands: () => Command[];
     /** The CLI's own settings, for keeping a failure that happened before its command could; plain ones without. */
     configuration?: {
-        resolveSettings: (flags?: GlobalFlags, options?: ResolveOptions) => Pick<Settings, "profile" | "keepFailedRuns" | "keepRunsForDays" | "skillHint">;
+        permissionKey?: (path: readonly string[]) => string | null | undefined;
+        resolveSettings: (flags?: GlobalFlags, options?: ResolveOptions) => Pick<Settings, "profile" | "keepFailedRuns" | "keepRunsForDays" | "skillHint"> & Partial<Pick<Settings, "permissions">>;
     };
     configure?: (program: Command) => void;
     /** The tool's pitch and "what you can do" lines on `--help` and a bare run. */

package/dist/cli/program.js

@@ -13,10 +13,11 @@ import { recorded, wasSettled } from "../runs/recording.js";
 import { processRun, useAsProcessRun } from "../runs/scope.js";
 import { AUTHORITY_KEY, BOT_API_KEY, isBotApi, keyForCommand } from "../sends/permissions.js";
 import { logParsedArgv, logVersion } from "./argv-log.js";
+import { commandAvailability } from "./command-availability.js";
 import { commandPathOf } from "./command-contract.js";
 import { outputFor, provide } from "./context.js";
 import { refuseWriteBeforeConnecting } from "./early-refusal.js";
-import { changesAuthorityNow, isLogin, isStoreChange, judgedEffects, judgedTargets, STORE_CHANGE_REFUSAL, } from "./effects.js";
+import { changesAuthorityAt, changesAuthorityNow, isLogin, isStoreChange, judgedEffects, judgedTargets, STORE_CHANGE_REFUSAL, } from "./effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "./envelope.js";
 import { byteCount, DEFAULT_COMMAND_MS, DEFAULT_OUTPUT_BYTES, execution } from "./execution.js";
 import { setupAtStart } from "./first-run.js";
@@ -193,6 +194,28 @@ const runOnce = async (argv, definition, options) => {
         platform: options.platform ?? process.platform,
         exit,
         runCommand: (words, given) => run(words, definition, given),
+        discoveryAvailability: (info) => {
+            const inspected = info.path.reduce((parent, word) => parent?.commands.find((one) => one.name() === word), program);
+            const flags = (inspected ?? program).optsWithGlobals();
+            const env = options.env ?? process.env;
+            if (!flags.profile && !env[envName(definition.app, "PROFILE")])
+                return undefined;
+            try {
+                const overrides = options.agent?.overrides ?? [];
+                const settings = (definition.configuration ?? settingsFor(definition.app)).resolveSettings(overrides.length ? { ...flags, permission: [...overrides, ...(flags.permission ?? [])] } : flags, {
+                    env,
+                    needsProfile: false,
+                    kind: info.path[0] === "bot" || flags.bot ? "bot" : "personal",
+                });
+                if (!settings.permissions)
+                    return undefined;
+                return commandAvailability(info, settings.permissions, definition.configuration?.permissionKey, changesAuthorityAt(program), readOnlyLockOf(definition.app, env) !== undefined, options.agent !== undefined);
+            }
+            catch {
+                // Help must still work when the configuration needs repair.
+                return undefined;
+            }
+        },
         untilStopped: () => {
             if (phased || finished)
                 return phase.signal;

package/dist/cli/result-fields.js

@@ -12,4 +12,22 @@ const named = (work) => {
     }
 };
 export const fieldsOf = (value) => named(() => coreFieldsOf(value));
-export const projectFields = (value, fields) => named(() => coreProjectFields(value, fields));
+const projectCommands = (commands, fields) => commands.map((command) => ({
+    ...coreProjectFields(command, fields),
+    path: command.path,
+    name: command.name,
+    origin: command.origin,
+    effects: command.effects,
+    commands: projectCommands(command.commands, fields),
+}));
+export const projectFields = (value, fields) => named(() => {
+    if (value &&
+        typeof value === "object" &&
+        "cli" in value &&
+        typeof value.cli === "string" &&
+        "contract" in value &&
+        "commands" in value &&
+        Array.isArray(value.commands))
+        return { ...value, commands: projectCommands(value.commands, fields) };
+    return coreProjectFields(value, fields);
+});

package/dist/entities/contact.d.ts

@@ -11,6 +11,12 @@ export declare const contact: v.StrictObjectSchema<{
     readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     /** The newest message in a one-to-one chat with them. */
     readonly last_messaged_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    /** For a source that knows it, such as a Zoom contact. */
+    readonly email: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly phones: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly number: v.StringSchema<undefined>;
+        readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
     /** `contacts show`: the chats shared with them. */
     readonly chats: v.OptionalSchema<v.ArraySchema<Omit<v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;

package/dist/entities/contact.js

@@ -13,6 +13,9 @@ export const contact = v.strictObject({
     description: v.nullable(text),
     /** The newest message in a one-to-one chat with them. */
     last_messaged_at: v.nullable(time),
+    /** For a source that knows it, such as a Zoom contact. */
+    email: v.optional(v.nullable(text)),
+    phones: v.optional(v.array(v.strictObject({ number: text, label: v.nullable(text) }))),
     /** `contacts show`: the chats shared with them. */
     chats: v.optional(v.array(v.pick(chat, ["ref", "id", "title", "kind", "last_message_at"]))),
     /** `contacts show --with-notes`: the owner's private notes about them. */