@wirecat/cli-core 0.393.0 → 0.395.0

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

@@ -130,7 +130,10 @@ export const tasksCommand = (messenger) => {
         ? "agent"
         : "owner";
     const tasks = new Command("tasks").description("what waits on you — unanswered questions, mentions, requests, promises — kept in the local store; review and serve add them");
-    withQuery(annotate(tasks.command("list"), { effects: LOCAL_READ }).description("tasks, oldest first, with their message or note source"), TASK_QUERY)
+    withQuery(annotate(tasks.command("list"), {
+        effects: LOCAL_READ,
+        examples: [`${tool} personal tasks list --limit 10`],
+    }).description("tasks, oldest first, with their message or note source"), TASK_QUERY)
         .option("--limit <n>", "how many", positiveCount("--limit"))
         .action(async function (words) {
         const context = messengerContext(this, messenger);
@@ -146,7 +149,10 @@ export const tasksCommand = (messenger) => {
         if (found.items.length === 0 && context.format === "pretty")
             context.renderer.note("no tasks — review, inbox and messages sync add them as questions arrive");
     });
-    planOptions(destroysNothing(annotate(tasks.command("add"), { effects: LOCAL_WRITE }))
+    planOptions(destroysNothing(annotate(tasks.command("add"), {
+        effects: LOCAL_WRITE,
+        examples: [`${tool} personal tasks add note:101 --type promise --category documents --title "Review draft"`],
+    }))
         .description("add a task for a stored message or note — a promise, a request")
         .argument("<message>", "a message locator, msg:<provider>/<account>/<chat>/<message>, or note:<id>")
         .requiredOption("--type <type>", "the task's type: question, request, mention or promise", taskTypeOf)
@@ -176,7 +182,10 @@ export const tasksCommand = (messenger) => {
         else if (followUpOf && context.format === "pretty")
             context.renderer.note(`${task.key ?? task.id} follows up ${followUpOf.key} (${followUpOf.status}), which stays closed: linked follow-up-of`);
     });
-    planOptions(destroysNothing(annotate(tasks.command("plan"), { effects: LOCAL_WRITE }))
+    planOptions(destroysNothing(annotate(tasks.command("plan"), {
+        effects: LOCAL_WRITE,
+        examples: [`${tool} personal tasks plan DOC-12 --title "Review draft"`],
+    }))
         .summary("set a task's title, description, due date, next check, category and assignee")
         .description("set a task's title, description, due date, next check, category and assignee; nothing reaches the messenger")
         .argument("<task>", "the task's id or key, as tasks list shows it")
@@ -189,7 +198,10 @@ export const tasksCommand = (messenger) => {
         const planned = await context.withServices((services) => services.tasks.plan(id, plan, writerOf(this)));
         renderAnswer(this, context, itemOf(snakeKeys(planned)), () => `${card(planned)}\n`);
     });
-    destroysNothing(annotate(tasks.command("link"), { effects: LOCAL_WRITE }))
+    destroysNothing(annotate(tasks.command("link"), {
+        effects: LOCAL_WRITE,
+        examples: [`${tool} personal tasks link DOC-12 https://example.com/draft`],
+    }))
         .description("link a task to messages, chats, people or URLs — or to another task: task:<id>")
         .argument("<task>", "the task's id or key, as tasks list shows it")
         .argument("[targets...]", "msg: locators, person:<id>, document:<id>, note:<id>, a URL; or task:<id>, which links two project tasks")
@@ -209,7 +221,7 @@ export const tasksCommand = (messenger) => {
         if (!("relations" in linked) && linked.review && context.format === "pretty")
             context.renderer.note(`${linked.review} possible duplicate pair(s) went to tasks duplicates`);
     });
-    annotate(tasks.command("show"), { effects: LOCAL_READ })
+    annotate(tasks.command("show"), { effects: LOCAL_READ, examples: [`${tool} personal tasks show DOC-12`] })
         .description("one task: its plan and everything linked to it")
         .argument("<task>", "the task's id or key, as tasks list shows it")
         .action(async function (id) {
@@ -307,7 +319,7 @@ export const tasksCommand = (messenger) => {
         const unmerged = await context.withServices((services) => services.tasks.unmerge(dup, writerOf(this)));
         renderAnswer(this, context, itemOf(snakeKeys(unmerged)), () => `${card(unmerged.task)}\n`);
     });
-    withQuery(annotate(tasks.command("agenda"), { effects: LOCAL_READ })
+    withQuery(annotate(tasks.command("agenda"), { effects: LOCAL_READ, examples: [`${tool} personal tasks agenda`] })
         .summary("what needs a look today: tasks due, chats you owe or wait on, what you are owed")
         .description("what needs a look today, from the local store and without message text: tasks overdue, due or to check, " +
         "chats where you owe an answer, chats where you wait for one, open tasks someone else does"), AGENDA_QUERY)

package/dist/cli/runs/command.js

@@ -18,7 +18,11 @@ export const runsCommand = (app) => {
             throw new CliError("not_found", `no recorded run "${id}" — \`${lineOf(from, "runs list")}\` shows them`);
         return found;
     };
-    annotate(command.command("list"), { effects: LOCAL_READ, mcp: false })
+    annotate(command.command("list"), {
+        effects: LOCAL_READ,
+        mcp: false,
+        examples: [`${app.command} runs list --limit 10`],
+    })
         .description("recorded runs, newest first")
         .option("--limit <n>", "how many to show", positiveCount("--limit"), 20)
         .option("--page <n>", "which page, starting at 1", positiveCount("--page"), 1)
@@ -32,7 +36,7 @@ export const runsCommand = (app) => {
         if (runs.length === 0)
             renderer.note("nothing recorded — a run is kept with `--record`, or when it fails");
     });
-    annotate(command.command("show"), { effects: LOCAL_READ, mcp: false })
+    annotate(command.command("show"), { effects: LOCAL_READ, mcp: false, examples: [`${app.command} runs show run-101`] })
         .argument("<run-id>", `an id from \`${app.command} runs list\``)
         .description("one run: what it was, how it ended, and every event it logged")
         .option("--problems", "only failed responses, warnings and crashes")
@@ -53,7 +57,10 @@ export const runsCommand = (app) => {
         if (shown.length < events.length)
             renderer.note(`${events.length - shown.length} other events — \`${lineOf(this, `runs show ${id}`)}\` shows them all`);
     });
-    annotate(command.command("search"), { effects: LOCAL_READ })
+    annotate(command.command("search"), {
+        effects: LOCAL_READ,
+        examples: [`${app.command} runs search timeout --limit 10`],
+    })
         .description("search recorded diagnostic metadata and events; no message contents")
         .argument("[query]", "case-insensitive literal diagnostic text")
         .addOption(new Option("--status <status>", "run outcome").choices(["success", "failed", "partial", "running"]))
@@ -79,7 +86,7 @@ export const runsCommand = (app) => {
             since_time: options.sinceTime,
         }));
     });
-    annotate(command.command("path"), { effects: NO_EFFECTS, mcp: false })
+    annotate(command.command("path"), { effects: NO_EFFECTS, mcp: false, examples: [`${app.command} runs path run-101`] })
         .argument("<run-id>", `an id from \`${app.command} runs list\``)
         .description("the directory holding one run")
         .action(function (id) {

package/dist/cli/skill-command.js

@@ -13,8 +13,13 @@ export const skillCommand = (app, skill) => {
     }, SHARED_SKILLS);
     // An installed skill is instructions every later agent follows.
     const install = command.commands.find((sub) => sub.name() === "install");
-    if (install)
+    if (install) {
         grantsAuthority(install);
+        annotate(install, { examples: [`${app.command} skill install --for agents`] });
+    }
+    const show = command.commands.find((sub) => sub.name() === "show");
+    if (show)
+        annotate(show, { examples: [`${app.command} skill show`, `${app.command} skill show follow-ups`] });
     return annotate(command, { mcp: false });
 };
 /** Skills this package ships for every CLI on it, printed by `skill show <name>`: `skills/` beside `dist/` and `src/`. */

package/dist/entities/index.d.ts

@@ -2857,7 +2857,7 @@ export declare const ENTITIES: {
     readonly saved_search: v.StrictObjectSchema<{
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly command: v.PicklistSchema<["search", "stats", "message-top", "author-top", "admin-statistics"], undefined>;
+        readonly command: v.PicklistSchema<["search", "stats", "message-top", "author-top", "admin-statistics", "meetings-search"], undefined>;
         readonly params: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
         readonly language: v.StringSchema<undefined>;
         readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;

package/dist/entities/saved-search.d.ts

@@ -4,7 +4,7 @@ export declare const savedSearch: v.StrictObjectSchema<{
     readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
     /** `null` for a run in the history. */
     readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly command: v.PicklistSchema<["search", "stats", "message-top", "author-top", "admin-statistics"], undefined>;
+    readonly command: v.PicklistSchema<["search", "stats", "message-top", "author-top", "admin-statistics", "meetings-search"], undefined>;
     /** The query and the options it runs with, as the command took them. */
     readonly params: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
     readonly language: v.StringSchema<undefined>;

package/dist/entities/saved-search.js

@@ -5,7 +5,7 @@ export const savedSearch = v.strictObject({
     id,
     /** `null` for a run in the history. */
     name: v.nullable(text),
-    command: v.picklist(["search", "stats", "message-top", "author-top", "admin-statistics"]),
+    command: v.picklist(["search", "stats", "message-top", "author-top", "admin-statistics", "meetings-search"]),
     /** The query and the options it runs with, as the command took them. */
     params: v.record(v.string(), v.unknown()),
     language: text,

package/dist/errors/reasons.js

@@ -51,6 +51,7 @@ const OTHERS = [
     validation("ranking.invalid", "the ranking is not valid"),
     validation("selection.changed", "the stored selection changed meanwhile"),
     validation("selection.invalid", "the selection is not valid"),
+    validation("search.kind", "the saved search belongs to another kind of search: messages or meetings"),
     ["selection.out-of-scope", "permission_error", "the selection reaches outside what this profile may read"],
     validation("stemmer.invalid", "the stemmer is not valid for that script"),
     validation("stemmer.newer", "the stems were built by a newer tool"),

package/dist/meetings/cli/search.js

@@ -35,7 +35,7 @@ export const createMeetingSearchCommand = (program) => {
     const command = search
         .command("meetings")
         .description("find words in stored meetings, indexing new ones first")
-        .argument("<query>", 'words, OR, (groups), -word, "a phrase", "a b"~N (within N lines), exact:word, from:"Name" (who said the line); a word also matches its other forms and spellings speech recognition garbled')
+        .argument("<query>", 'words, OR, (groups), -word, "a phrase", "a b"~N (within N lines), exact:word, from:"Name" (who said the line); date>=30d, project:, tag:, topic: choose meetings; a word also matches its other forms and spellings speech recognition garbled')
         .option("--meeting-id <id>", "only this stored meeting", integer)
         .option("--identity-id <id>", "meetings with this participant identity; does not say who spoke a hit", integer)
         .option("--person-id <id>", "meetings with a participant linked to this person", integer)

package/dist/meetings/hit-query.d.ts

@@ -1,8 +1,18 @@
 import { type QueryAst } from "@wirecat/cli-base/query";
+import type { MeetingHitSearchRequest } from "./search-store.js";
 /** A transcript line holds a sentence or two; further than this is a different part of the meeting. */
 export declare const MOST_LINES_APART = 20;
 /** The messages query language over meeting text: the same fields, a narrower set of operators. */
 export declare const MEETING_HIT_QUERY: import("@wirecat/cli-base/query").QueryRegistry;
+/**
+ * `budget project:RES date>=30d` → the words, and the meetings to look in as filters. A meeting field must be
+ * joined to the words with AND and given once, in the query or as an option. Text the language refuses is left as
+ * typed, for the caller's own error or for a search by meaning.
+ */
+export declare const liftMeetingFields: (query: string, request: MeetingHitSearchRequest, now?: number) => {
+    query: string;
+    request: MeetingHitSearchRequest;
+};
 /** What a person typed: the CLI, MCP and batch queries. */
 export declare const parseMeetingQuery: (query: string) => QueryAst;
 /**

package/dist/meetings/hit-query.js

@@ -1,4 +1,5 @@
-import { defineQuery, parseLucene, queryError, validateQuery, } from "@wirecat/cli-base/query";
+import { CliError } from "@wirecat/cli-base";
+import { dateRange, defineQuery, parseLucene, queryError, timezoneOf, validateQuery, } from "@wirecat/cli-base/query";
 const context = {
     command: "search meetings",
     guide: "https://github.com/WireCatLabs/cli-core/blob/main/docs/search/query-language.md#встречи",
@@ -40,6 +41,89 @@ export const MEETING_HIT_QUERY = defineQuery({
         },
     ],
 });
+/** Fields that choose meetings rather than lines: lifted out of the query into the search's own filters. */
+const MEETING_FIELDS = defineQuery({
+    entity: "meeting_hit",
+    backend: "sql",
+    fields: [
+        ...MEETING_HIT_QUERY.fields,
+        {
+            name: "date",
+            type: "time",
+            operators: ["term", "range"],
+            example: "date>=30d",
+            relation: "meetings that started then; the same as --since-time and --until-time",
+        },
+        ...["project", "tag", "topic"].map((name) => ({
+            name,
+            type: "kw",
+            operators: words,
+            example: `${name}:"Example name"`,
+            relation: `meetings in this ${name}, by name or alias; the same as --${name}`,
+        })),
+    ],
+});
+const LIFTED = new Set(["date", "project", "tag", "topic"]);
+/**
+ * `budget project:RES date>=30d` → the words, and the meetings to look in as filters. A meeting field must be
+ * joined to the words with AND and given once, in the query or as an option. Text the language refuses is left as
+ * typed, for the caller's own error or for a search by meaning.
+ */
+export const liftMeetingFields = (query, request, now) => {
+    let ast;
+    try {
+        ast = validateQuery(parseLucene(query, { defaultField: "text", proximity: true, ...context }), MEETING_FIELDS, context);
+    }
+    catch (error) {
+        if (error instanceof CliError)
+            return { query, request };
+        throw error;
+    }
+    const top = ast.root.kind === "boolean" ? ast.root.clauses : [{ occur: "must", node: ast.root }];
+    const lifted = top.filter((clause) => clause.node.kind === "predicate" && LIFTED.has(clause.node.field));
+    const misplaced = (node, nested) => node.kind === "predicate"
+        ? nested && LIFTED.has(node.field)
+            ? node
+            : undefined
+        : node.clauses.map((clause) => misplaced(clause.node, true)).find(Boolean);
+    const wrong = lifted.find((clause) => clause.occur !== "must")?.node ??
+        top.map((clause) => (clause.node.kind === "boolean" ? misplaced(clause.node, true) : undefined)).find(Boolean);
+    if (wrong)
+        queryError("query.unsupported-field", wrong.span, `${wrong.field}: chooses meetings; join it to the words with AND, outside OR, NOT and groups`, context);
+    if (!lifted.length)
+        return { query, request };
+    const next = { ...request };
+    const once = (name, flag) => {
+        if (next[name] !== undefined)
+            throw new CliError("validation_error", `give ${flag.replace(/^--/, "")} once: as ${flag} or in the query`);
+    };
+    for (const { node } of lifted) {
+        if (node.field === "date") {
+            once("since", "--since-time");
+            once("until", "--until-time");
+            const range = dateRange(node.value, node.operator === "range" ? (node.upper ?? "*") : node.value, node.lower_inclusive !== false, node.upper_inclusive !== false, timezoneOf(), node.span, now);
+            if (range.lower !== undefined)
+                next.since = range.lower + (range.lower_inclusive ? 0 : 1);
+            if (range.upper !== undefined)
+                next.until = range.upper - (range.upper_inclusive ? 0 : 1);
+        }
+        else {
+            const field = node.field;
+            once(field, `--${field}`);
+            next[field] = node.value;
+        }
+    }
+    let rest = query;
+    for (const { node } of [...lifted].sort((a, b) => b.node.span.start - a.node.span.start))
+        rest = `${rest.slice(0, node.span.start)}${rest.slice(node.span.end)}`;
+    rest = rest
+        .replace(/^(?:\s*AND\b)+|(?:\bAND\s*)+$/g, "")
+        .replace(/\bAND(\s+AND\b)+/g, "AND")
+        .trim();
+    if (!rest)
+        throw new CliError("validation_error", "give words to find besides date:, project:, tag: and topic:");
+    return { query: rest, request: next };
+};
 /** What a person typed: the CLI, MCP and batch queries. */
 export const parseMeetingQuery = (query) => validateQuery(parseLucene(query, { defaultField: "text", proximity: true, ...context }), MEETING_HIT_QUERY, context);
 /**

package/dist/meetings/index.d.ts

@@ -6,7 +6,7 @@ export { linkEvent } from "./events.js";
 export { exportMeeting, type MeetingExport, type MeetingExportFormat, type MeetingExportOptions, serializeVtt, } from "./export.js";
 export { type FindingEvidence, type FindingOutcome, findingHash, MEETING_FINDINGS_KIND, type MeetingFactFinding, type MeetingFinding, type MeetingFindingsInput, type MeetingFindingsReceipt, type MeetingTaskFinding, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";
 export { type Finding, type FindingsInput, type FindingsReceipt, type FindingsRules, findingFingerprint, validateFindings, } from "./findings-rules.js";
-export { MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
+export { liftMeetingFields, MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { type ImportFile, importFiles } from "./import.js";
 export { MEETING_ISSUES, MEETING_QUERY, type MeetingIssue, type MeetingItem, type MeetingOwner, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
 export { CHAT_MESSAGES_READ, type MeetingChatLine, type MeetingChatLinesInput, type MeetingChatLinesStore, } from "./links.js";

package/dist/meetings/index.js

@@ -4,7 +4,7 @@ export { linkEvent } from "./events.js";
 export { exportMeeting, serializeVtt, } from "./export.js";
 export { findingHash, MEETING_FINDINGS_KIND, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";
 export { findingFingerprint, validateFindings, } from "./findings-rules.js";
-export { MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
+export { liftMeetingFields, MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { importFiles } from "./import.js";
 export { MEETING_ISSUES, MEETING_QUERY, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
 export { CHAT_MESSAGES_READ, } from "./links.js";

package/dist/sends/permissions.js

@@ -450,7 +450,8 @@ export const keyForCommand = (path) => {
         return path.join(".");
     if (top === "messages" && next === "sync")
         return "messages";
-    if (SHOW_MESSAGES.has(top) || (top === "contacts" && (next === "context" || next === "timeline")))
+    if (SHOW_MESSAGES.has(top) ||
+        (top === "contacts" && (next === "context" || next === "prepare" || next === "timeline")))
         return "messages";
     if (RESOURCES.includes(top))
         return path.join(".");

package/dist/services/index.d.ts

@@ -69,6 +69,7 @@ export { type MeetingLink, type MeetingLinksRequest, readMeetingLinks } from "./
 export { createMeetingProjectCandidateReader } from "./meeting-project-candidates.js";
 export { readMeetingProjectDiscovery } from "./meeting-project-discovery.js";
 export { type MeetingReviewRequest, readMeetingReview } from "./meeting-review.js";
+export { type MeetingSearchesService, type MeetingSearchParams, meetingSearchesService, type SavedMeetingSearch, } from "./meeting-searches.js";
 export { type MeetingStatsRequest, readMeetingStats } from "./meeting-stats.js";
 export { chatIdIn, storedChatId } from "./message-resolution.js";
 export type { AroundWindow, FoundMessage, ListWindow, MessagesService, MessageTarget, Pinned, Reacted, SearchFound, SearchQuery, SendRequest, Starred, } from "./messages.js";
@@ -80,14 +81,16 @@ export type { ContactSync, PeopleService } from "./people.js";
 export { peopleService, phoneOf } from "./people.js";
 export type { ContextMessage, ContextOptions, NotReadReason, PersonContext, SharedChat, } from "./person-context.js";
 export { CONTEXT_BYTES, CONTEXT_MESSAGES, identityIn, personContext } from "./person-context.js";
+export type { PersonPreparation, WaitingDialog } from "./person-preparation.js";
+export { PREPARE_BYTES, personPreparation } from "./person-preparation.js";
 export type { PersonTimeline, Scope, TimelineItem, TimelineOptions } from "./person-timeline.js";
 export { personTimeline, SCOPES, TIMELINE_ITEMS, TIMELINE_MAX } from "./person-timeline.js";
 export type { RankedRow, RankingFound, RankingQuery, RankingsService } from "./rankings.js";
 export { rankingsService } from "./rankings.js";
 export type { SearchParams } from "./search-record.js";
 export { searchRecordOf } from "./search-record.js";
-export type { ResolvedSearch, SearchesService } from "./searches.js";
-export { searchesService } from "./searches.js";
+export type { ResolvedSearch, SavedSearchItem, SearchesService } from "./searches.js";
+export { savedSearchItem, searchesService } from "./searches.js";
 export type { TagsAdded, TagsRemoved, TagsService, TagTargetInput, TagTargetView } from "./tags.js";
 export { tagsService } from "./tags.js";
 export type { ClosedTask, TaskCard, TaskItem, TaskList, TaskListRequest, TasksService, TaskView, } from "./tasks.js";

package/dist/services/index.js

@@ -50,6 +50,7 @@ export { readMeetingLinks } from "./meeting-links.js";
 export { createMeetingProjectCandidateReader } from "./meeting-project-candidates.js";
 export { readMeetingProjectDiscovery } from "./meeting-project-discovery.js";
 export { readMeetingReview } from "./meeting-review.js";
+export { meetingSearchesService, } from "./meeting-searches.js";
 export { readMeetingStats } from "./meeting-stats.js";
 export { chatIdIn, storedChatId } from "./message-resolution.js";
 export { DELETE_AT_ONCE, messagesService } from "./messages.js";
@@ -57,10 +58,11 @@ export { searchStore } from "./messages-archive-search.js";
 export { moderationService } from "./moderation.js";
 export { peopleService, phoneOf } from "./people.js";
 export { CONTEXT_BYTES, CONTEXT_MESSAGES, identityIn, personContext } from "./person-context.js";
+export { PREPARE_BYTES, personPreparation } from "./person-preparation.js";
 export { personTimeline, SCOPES, TIMELINE_ITEMS, TIMELINE_MAX } from "./person-timeline.js";
 export { rankingsService } from "./rankings.js";
 export { searchRecordOf } from "./search-record.js";
-export { searchesService } from "./searches.js";
+export { savedSearchItem, searchesService } from "./searches.js";
 export { tagsService } from "./tags.js";
 export { closedStateOf, taskStateOf, tasksService, taskTypeOf, taskView } from "./tasks.js";
 export { topicsService } from "./topics.js";

package/dist/services/meeting-combined.d.ts

@@ -38,7 +38,7 @@ export interface MeetingCombinedHit {
  */
 export declare const searchMeetingsCombined: (store: Pick<MessageStore, "meetings" | "meetingVectors"> & {
     knowledge?: MessageStore["knowledge"];
-}, embedder: MeetingEmbedder, query: string, request: MeetingCombinedRequest) => Promise<{
+}, embedder: MeetingEmbedder, typed: string, request: MeetingCombinedRequest) => Promise<{
     items: {
         /** A transcript line to cite: the best word hit in the passage, else the passage's first line. */
         ref: string;

package/dist/services/meeting-combined.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
 import { meaningFloor } from "../embeddings/models.js";
-import { formatMeetingReference, parseMeetingReference, } from "../meetings/index.js";
+import { formatMeetingReference, liftMeetingFields, parseMeetingReference, } from "../meetings/index.js";
 import { questionTerms } from "../search/question-plan.js";
 import { refreshMeetingIndex, resolveMeetingSelection } from "./meeting-hit-search.js";
 import { validateVector } from "./meeting-semantic.js";
@@ -27,8 +27,9 @@ const cursorOf = (value, key) => {
  * («что решили по цене?») searches its content words; other text is the meeting query language. A word hit inside
  * a passage the meaning search found joins it, so one discussion found both ways ranks first.
  */
-export const searchMeetingsCombined = async (store, embedder, query, request) => {
-    const { maxChunks, maxRows, maxTextBytes, ...words } = request;
+export const searchMeetingsCombined = async (store, embedder, typed, request) => {
+    const { maxChunks, maxRows, maxTextBytes, ...chosen } = request;
+    const { query, request: words } = liftMeetingFields(typed, chosen);
     const { input, selection } = await resolveMeetingSelection(store, words);
     const { after, limit = 20, maxReadBytes, ...filters } = input;
     const terms = questionTerms(query);

package/dist/services/meeting-hit-search.d.ts

@@ -1,4 +1,4 @@
-import type { MeetingHitSearchRequest } from "../meetings/index.js";
+import { type MeetingHitSearchRequest } from "../meetings/index.js";
 import type { VocabularyKind } from "../store/index.js";
 import type { MessageStore } from "../store/store.js";
 export type { MeetingHitSearchRequest } from "../meetings/index.js";

package/dist/services/meeting-hit-search.js

@@ -1,4 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
+import { liftMeetingFields } from "../meetings/index.js";
 /** Each batch commits on its own, so a search cut short by its deadline keeps the progress it made. */
 export const refreshMeetingIndex = async (meetings, accountId, signal) => {
     let before = Number.POSITIVE_INFINITY;
@@ -54,10 +55,11 @@ export const resolveMeetingSelection = async (store, request) => {
     return { input, selection };
 };
 export const searchMeetingHits = async (store, query, request, options = {}) => {
-    const { input, selection } = await resolveMeetingSelection(store, request);
+    const lifted = liftMeetingFields(query, request);
+    const { input, selection } = await resolveMeetingSelection(store, lifted.request);
     if (options.refreshIndex !== false)
         await refreshMeetingIndex(store.meetings, input.accountId, input.signal);
-    const result = await store.meetings.searchHits(query, input);
+    const result = await store.meetings.searchHits(lifted.query, input);
     input.signal?.throwIfAborted();
     return { ...result, selection };
 };

package/dist/services/meeting-searches.d.ts

@@ -0,0 +1,25 @@
+import type { SearchesStore, StoredSearch } from "../store/store.js";
+/** A meeting search as `search meetings` takes it: the query and the options typed with it, already checked. */
+export interface MeetingSearchParams {
+    query: string;
+    options: Readonly<Record<string, string | number | boolean>>;
+}
+export interface SavedMeetingSearch extends MeetingSearchParams {
+    id: string;
+    name: string | null;
+}
+export interface MeetingSearchesService {
+    create(name: string, params: MeetingSearchParams, options?: {
+        replace?: boolean;
+    }): Promise<StoredSearch>;
+    list(): Promise<StoredSearch[]>;
+    show(reference: string): Promise<StoredSearch>;
+    delete(reference: string): Promise<StoredSearch>;
+    /** `--saved`: the stored query and options, counted as one more run. */
+    run(reference: string): Promise<SavedMeetingSearch>;
+}
+/**
+ * Saved meeting searches, in the table every CLI on the store shares: only rows of their own kind are listed, and a
+ * saved message search is refused by name rather than run as a meeting one.
+ */
+export declare const meetingSearchesService: (searches: () => Promise<SearchesStore>) => MeetingSearchesService;

package/dist/services/meeting-searches.js

@@ -0,0 +1,35 @@
+import { CliError, singleLine } from "@wirecat/cli-base";
+import { searchRecordOf } from "./search-record.js";
+import { nameOf } from "./searches.js";
+const KIND = ["meetings-search"];
+/**
+ * Saved meeting searches, in the table every CLI on the store shares: only rows of their own kind are listed, and a
+ * saved message search is refused by name rather than run as a meeting one.
+ */
+export const meetingSearchesService = (searches) => {
+    const found = async (reference) => {
+        const search = await (await searches()).storedSearch(reference.trim().toLowerCase());
+        if (!search)
+            throw new CliError("not_found", `no saved search "${singleLine(reference)}"`);
+        if (search.command !== "meetings-search")
+            throw new CliError("validation_error", `"${singleLine(reference)}" is a saved search of messages, not meetings`, {
+                reason: "search.kind",
+                command: search.command,
+            });
+        return search;
+    };
+    const record = ({ query, options }) => searchRecordOf("meetings-search", { ...options, text: query });
+    return {
+        create: async (name, params, { replace = false } = {}) => (await searches()).saveSearch(nameOf(name), record(params), { replace }),
+        list: async () => (await searches()).savedSearches(KIND),
+        show: found,
+        delete: async (reference) => (await searches()).deleteSearch((await found(reference)).id),
+        run: async (reference) => {
+            const search = await found(reference);
+            const { text, ...options } = search.params;
+            const query = { query: String(text ?? ""), options };
+            await (await searches()).recordSearch(record(query), { saved: search.id });
+            return { id: search.id, name: search.name, ...query };
+        },
+    };
+};

package/dist/services/people.d.ts

@@ -5,6 +5,7 @@ import type { PersonRecord } from "../store/store.js";
 import type { PageWindow } from "./chats.js";
 import { type ServiceDeps } from "./deps.js";
 import { type ContextOptions, type Detail, type PersonContext, type PersonMessages } from "./person-context.js";
+import { type PersonPreparation } from "./person-preparation.js";
 import { type PersonTimeline, type TimelineOptions } from "./person-timeline.js";
 export interface ContactSync {
     added: number;
@@ -52,6 +53,10 @@ export interface PeopleService {
     }>>;
     /** What the store holds about them, across every messenger linked to them; never connects. */
     context(person: string, options?: ContextOptions): Promise<PersonContext>;
+    /** `context` and what to know before talking to them: chats waiting on you, tasks, facts, notes, meetings. */
+    prepare(person: string, options?: ContextOptions & {
+        notes?: boolean;
+    }): Promise<PersonPreparation>;
     /** Everything they took part in, from the store's involvement index; never connects. */
     timeline(person: string, options?: TimelineOptions): Promise<PersonTimeline>;
     /**

package/dist/services/people.js

@@ -8,6 +8,7 @@ import { newOperationId } from "../sends/send-id.js";
 import { fromStore, storeIfOpen } from "./deps.js";
 import { storedChatId } from "./message-resolution.js";
 import { CHAT_MESSAGES, identityIn, personContext, personMessages, } from "./person-context.js";
+import { personPreparation } from "./person-preparation.js";
 import { personProfile } from "./person-profile.js";
 import { personTimeline } from "./person-timeline.js";
 export const peopleService = (deps) => {
@@ -75,6 +76,7 @@ export const peopleService = (deps) => {
         },
         profile: (person) => personProfile(deps, person),
         context: async (person, options) => personContext(await deps.store(), await deps.account(), person, options),
+        prepare: async (person, options) => personPreparation(await deps.store(), await deps.account(), person, options),
         timeline: async (person, options) => personTimeline(await deps.store(), await deps.account(), person, options),
         messagesIn: async (person, { chats, limit, detail, fetch = false }) => {
             const store = await deps.store();

package/dist/services/person-context.d.ts

@@ -1,5 +1,5 @@
-import type { ChatKind, Id, Provider } from "../domain/models.js";
-import type { AccountKey, IdentityRef, MessageStore, PersonRecord } from "../store/store.js";
+import type { ChatKind, Id, Message, Provider } from "../domain/models.js";
+import type { AccountKey, IdentityRef, LinkedIdentity, MessageStore, PersonRecord } from "../store/store.js";
 export declare const CONTEXT_MESSAGES = 10;
 export declare const CONTEXT_BYTES: number;
 export interface ContextMessage {
@@ -60,6 +60,16 @@ export interface ContextOptions {
     /** ms: nothing older. */
     since?: number;
 }
+export declare const toContext: (key: AccountKey, message: Message, chatTitle: string | null) => ContextMessage;
+/**
+ * The accounts each identity is read in: for the messenger asked, only the account asked about — a
+ * second account of the same messenger is somebody else's view; for a linked messenger, every account
+ * of this store that saw that identity.
+ */
+export declare const readsOf: (record: PersonRecord, asked: AccountKey) => {
+    key: AccountKey;
+    identity: LinkedIdentity;
+}[];
 /**
  * What the store knows about one person, across every identity linked to them. Reads the store
  * only: nothing is fetched, nothing marked read. Identity is by id, never by name.

package/dist/services/person-context.js

@@ -4,7 +4,7 @@ import { pickPerson } from "../resolve.js";
 import { messageOfEmail } from "../store/store.js";
 export const CONTEXT_MESSAGES = 10;
 export const CONTEXT_BYTES = 64 * 1024;
-const toContext = (key, message, chatTitle) => ({
+export const toContext = (key, message, chatTitle) => ({
     locator: formatLocator({ ...key, chat: message.chatId, message: message.id }),
     provider: key.provider,
     account: key.account,
@@ -49,7 +49,7 @@ const newestFirst = (a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp);
  * second account of the same messenger is somebody else's view; for a linked messenger, every account
  * of this store that saw that identity.
  */
-const readsOf = (record, asked) => record.identities.flatMap((identity) => (identity.provider === asked.provider ? [asked.account] : identity.accounts)
+export const readsOf = (record, asked) => record.identities.flatMap((identity) => (identity.provider === asked.provider ? [asked.account] : identity.accounts)
     .filter((account) => identity.accounts.includes(account))
     .map((account) => ({ key: { provider: identity.provider, account }, identity })));
 /**