The shared CLI/MCP adapters for project-name evidence are documented in Project-word evidence. Applications opt into these exports explicitly.
src/meetings/, exported as @wirecat/cli-core/meetings (and /meetings/cli, /meetings/mcp,
/meetings/testing); up to 0.4.2 it was the separate package @wirecat/cli-meetings. Each meeting provider
is its own package that implements MeetingSource; the shared store implements MeetingStore; this module
owns everything between them.
An event is the owner's own record of something that happened, as a person is the owner's own record of someone. A meeting is what one external app knows about it: a Zoom occurrence, a Fireflies recording. Several meetings can point at one event, as several identities point at one person. Later a calendar entry points at the same event.
persons ◄── identity_links ── identities (a Zoom user, a Telegram user, …)
▲ meeting_participants
event_series ◄── events ◄── meetings ── transcripts → utterances, chat, summaries, documents
▲
└── later: calendar entries
cli-base ← cli-core (src/meetings/ ← the rest of src/) ← zoom-cli (zm)
src/meetings/— the model, the WebVTT parser, source and store ports, and what runs on them: pull, import, event linking, commands and MCP reads. Optional provider ports add meeting management, recording transfer, archive synchronization and schedule planning. No SQLite, no filesystem and no import from the rest of the package: the lint rules inbiome.jsonrefuse them undersrc/meetings/.- the rest of cli-core — the tables, in its single list of store migrations, and
MeetingStoreover SQLite, as it does for theTaskStoreofsrc/tasks/. It also owns bounded durable evidence, person context, embedding bindings and semantic services that depend on the shared knowledge store. - A provider (
zoom-clifirst) — login, the API client, and oneMeetingSourceper way in:api,files,browser. It opens the shared store through cli-core and hands both ports to the meetings commands.
| File | What |
|---|---|
src/model.ts |
events, meetings, participants, transcripts, chat, summaries and attachments |
src/vtt.ts |
parseVtt: WebVTT cues to transcript lines, the speaker taken from Name: text |
src/transcript-text.ts |
parseTranscriptText: the text form zoom-searcher wrote — a header (Встреча:, Дата:, Zoom ID:, Говорят:) and [hh:mm:ss] Speaker: text blocks; the header as written, the date for the caller to read in its zone |
src/store.ts |
MeetingStore, atomic writes and meeting/event reads |
src/source.ts |
MeetingSource, the port a provider implements |
src/pull.ts |
fetch occurrence parts and save them |
src/import.ts |
parse files supplied by the caller |
src/events.ts |
preserve links, match or create an event |
src/cli/index.ts |
Commander commands |
src/mcp/index.ts |
schemas and read dispatcher |
src/testing/index.ts |
memory store, fake source and contract cases |
src/provider.ts |
fixed opaque provider/account scope |
src/meeting-management.ts |
optional remote read/write ports, portable validation and explicit mutation dispatch |
src/recording-source.ts |
provider-neutral recording catalog and asset metadata |
src/recording-transfer.ts |
bounded transfer and strong-validator resume over source/storage ports |
src/recording-sync.ts |
discovery windows, archive acknowledgements and checkpoint orchestration |
src/recording-schedule.ts |
pure schedule definitions and explicit host scheduler installation |
These capabilities compose independently of MeetingSource and MeetingStore; their existing
contracts remain unchanged. A provider can supply recordings without mutation support, or remote
management without transcripts. Provider IDs and accounts stay opaque. Provider-specific meeting
types, HTTP request bodies and credentials never enter the shared SDK. Host adapters own filesystem
safety, URL trust, authentication and OS timers. See provider integration.
The stored model follows the shared store schema: integer ids, epoch millisecond timestamps,
metadata for provider extras, and transcript rows keyed by transcript and position. Source data
uses separate types until the store assigns ids.
In the shared store, created by cli-core. Times are epoch milliseconds. Every table that holds a
provider's record has metadata, JSON, for whatever has no column yet.
| Table | One row is |
|---|---|
events |
the owner's event: title, start, end, time zone, whether a pull or the owner made it |
event_series |
a repeating event, above any one provider's recurrence |
meeting_series |
a provider's recurring or scheduled meeting: title, kind, recurrence, host, join link |
meetings |
one occurrence: start, end, duration, host, and the event it belongs to |
meeting_participants |
one person in one meeting: their identity, the name and email shown in that meeting, role, joins and leaves |
meeting_transcripts |
one transcript of a meeting: its source, format, language and content hash |
meeting_transcript_rows |
one line of a transcript: start, end, speaker, text |
meeting_chat_messages |
one message of the in-meeting chat |
meeting_summaries |
one summary: title, overview, sections, next steps, the full text, which tool made it |
attachments |
one file a meeting has: a recording, a shared file, a whiteboard — a pointer, not the file |
Meeting text gets its own word and stem indexes, built the way the notes' are, so a query means the same for messages, notes and meetings — with one difference. Speech recognition garbles words, and a correct and a garbled spelling sit in one meeting, so meeting search always widens a word of four letters or more to the stored words recognition may have made of it, instead of only when nothing matched as messages do:
- a stem one edit away that a Russian dictionary (
dictionary-ru, Hunspell) does not know: «риелтор» finds «реелтора», «рилторов», «дриелтора», but «договор» does not find «поговорить», a real word one edit away. Below seven letters the first letter must agree; - a stem one side extends, when the other side's word spells the extension out: «циана» (stem
циа) finds «цианом» (циан), «устав» does not find «установить»; - е and э compared as one letter (ё already folds into е in the index).
The dictionary loads only when a query has such spellings to check, in about 0.15 s: it is read the way Hunspell checks a word, an ending at a time, not expanded into all its forms. On a copy of a real store of 119 meetings it cut the widened passages from 10,271 to 1,157 over 130 queries. ztx's rule that a stored word of four letters or more beginning the query word matches is kept behind the same dictionary: speech recognition cuts words off («може» for «может», «напри» for «например»), while the real shorter words it also reached — «после» for «последующих», «отдел» for «отдельно», «пока» for «показывал» — are dictionary words. Over 45 queries from April to September on that copy, ztx found 45,833 lines; without the rule zm missed 357 of them, 280 of those real other words.
Number words never widen, and match only their own forms, not as the start of a longer word: recognition swaps
them, «десять» is one edit from «девять», and «семь» begins «семьдесят». exact:word and
exact:"two words" keep those words to their typed form: no other forms, no widening. Hits come in three tiers:
the typed form, then other forms of the word (stems merge some different words: «устав» and «устал» share уста,
and a dictionary cannot split them, since «устав» is also a form of «устать»), then garbled spellings;
a widened hit has match: "corrected" and corrections (from, the query word, and to, the stored words it
matched in that passage). Widening reads the whole word list once per query, with no table of its own: a median
of 0.11 s a query on that copy (measurement).
- Nothing is lost. A pull never deletes. What a provider stops returning is marked gone; a transcript whose text changed is a new transcript, and the old one stays.
- A participant is an identity, not a contact. Keyed by the provider's user id, else email, else a name that counts only inside its meeting, so two strangers with one name never merge. The name shown in each meeting stays with that meeting. A contact is someone with a one-to-one chat, which a meeting never creates; the owner links a participant to a person when it is the same human.
- Sources point at events; events point at nothing. That is what lets a calendar, or a second meeting app, join later without changing the meeting tables.
- Meetings are not messages. Messages are for messengers; meetings, their lines and their chat live in their own tables.
- One occurrence, one record. A save marked
fromFile(a transcript read from a file) and a provider's record of the same occurrence — same series key, starts within 15 minutes — are one meeting. The provider's record wins: saved after a file, it takes over the record and its key; a file saved after it only fills a missing transcript, and a provider transcript supersedes transcripts with sourcefile. Two provider records are never merged (a restarted meeting is a new occurrence), and a file without the provider's series key (a.vttnamed only by its topic) cannot be matched.
saveMeeting takes the occurrence and its available parts in one call, keyed by account and external
id. The store assigns ids and resolves participant identities in the same transaction. Speaker
positions refer to the participants in that save. Omitted parts retain existing data. Changed
transcripts add a version and supersede the prior version from the same source; identical hashes
skip re-import. Automatic linking preserves existing event links. Cursors are scoped to accounts.
src/testing/index.ts exports the memory adapter, a fake provider,
invented samples and meetingStoreContract(make). Every case gets an empty adapter; the caller owns
its lifecycle. Cases cover retained history, idempotence, account isolation, identity matching,
ambiguous speakers, atomic failure, search, filters, event linking and cursors. The memory adapter
uses substring search to exercise the port; it does not implement the production word/stem index.
pull(source, store, { accountId, since, now, lookbackMs }) reads participants, transcript, chat, summary and files
in order for each occurrence, then saves and links its event. Missing parts remain unknown; a failed
occurrence produces a warning, processing continues, and the cursor stays unchanged so it can retry.
Discovery failures reject the pull before any occurrence is processed. A successful pull advances
its account cursor to now, even when some parts are unavailable (null). By default this cursor
only covers occurrence discovery; it does not guarantee that transcripts appearing later will be
fetched. Callers can supply an explicit lookbackMs (integer milliseconds, zero through 31 days) to
subtract from the selected since or stored cursor, revisiting a bounded discovery window. Its default
is zero. Parts that appear outside the window require an older explicit since.
The source reports whether its series is recurring. Participants carry identity keys; a cue matches only one participant with that name. Name clashes preserve the cue's name with a null speaker link.
importFiles takes file contents and meeting metadata supplied by the caller. It reads no folder. A file's format picks the parser: vtt (the default) or text.
SHA-256 hashes skip repeated transcript content; corrected versions supersede only the same source.
linkEvent preserves existing links, matches overlapping series or join links, and creates an event
when no single match exists. Recurring meetings also create an event series when needed. Linking refreshes the stored meeting
first and reads back its actual link after automatic linking, preserving a concurrent owner update.
Event creation and linking are separate store calls: concurrent callers can still create unused
events or event series. The current port cannot guarantee atomic event selection, creation and linking;
callers should serialize ingestion for the same account. A join-link match does not automatically
merge the incoming provider's recurring series into the matched event series. Stronger atomic and
series inheritance guarantees require coordination with the SQLite adapter.
src/cli/index.ts mounts Commander commands on a host program. Dependencies
supply the selected account, store, source, file reader, output writer and clock. Show and transcript
are scoped to that account. meetings sync runs pull and exposes --lookback-days <days>, an integer
from zero through 31 (default zero), forwarding days as lookbackMs. It subtracts from the selected
boundary, including an explicit --since-time (an ISO date or time, or 7d ago, read by the shared dateWindow);
invalid bounds fail before provider discovery. meetings list pages by --limit and --page, and without
--limit by the profile's defaults.limit, which the required pagingOf dependency reads (pagingOf from
@wirecat/cli-core/cli; a test outside cli-core's run passes flagPaging from /meetings/testing). --json [fields] and --jsonl are the host program's own. A transcript's
language is set when it is written (transcriptLanguage, or the speech model's own); meetings repair
previews it for stored transcripts that have none and --yes stores it, through the store's optional
fillTranscriptLanguages. A sync and an import that saved meetings bring the account's search index up to date
before they answer (refreshMeetingIndex, through the store's optional indexSearch), so search all, which only
reads the index, finds their words; a failure is a warning, and a sync its budget stopped leaves it to the next run.
Groups have no default action. The host owns rendering and exit codes.
src/mcp/index.ts exports JSON schemas, read annotations and a dispatcher
for the meeting read tools. The server owns registration and access policy. Arguments use snake case
and are checked before execution. Results include JSON text and structured content; errors set
isError. Both surfaces use src/reads.ts, including the list page envelope.
A provider that mails its notes instead of offering an API is a MeetingSource over stored mail
(src/mail/meeting-notes.ts). A mail rule with meeting_notes: "<provider>"
picks the emails; MEETING_NOTES holds each provider's senders, the day in its subject, the zones that day may be
written in and the headings its notes are cut under. Each email is one meeting, keyed by its Message-ID, so a room
used for many meetings never merges them. The notes give the day only: the event the meeting is already linked to,
or the owner's one calendar entry in the same room that day, gives the hours; without one the meeting starts at the
day's start, metadata.time_precision is day, and createsEvents: false keeps linkEvent from making an event
at midnight. syncMail calls saveMeetingNotes once, after its rounds, reading only the rules' senders' mail when
every rule names one; a caller backfills older mail with an early since. Telemost is the first provider: its web
app keeps no notes, and its API reads only scheduled meetings for Yandex 360 for Business.
Moved from cli-meetings' roadmap when that repository was retired. Zoom, through zoom-cli (zm), is the
first provider. Each one below is a source behind the same port; nothing above the port changes when one
is added.
- Google Meet — transcripts and recordings from Google Workspace.
- Microsoft Teams — transcripts and meeting chat through Microsoft Graph.
- Meeting-assistant bots that already transcribe and summarise — Fireflies and similar services — read through their APIs as one more source.
- A browser source for Zoom, for accounts whose admin does not approve the app and for meetings the user only attended.
- Later, calendars — Google Calendar and others. A calendar entry is one more source for an event, next to the meetings: it points at the same event, its invitees are identities like meeting participants, and a recurring entry points at the same event series. Nothing for calendars is built yet; the event tables are shaped so that adding them changes no meeting code.
meetings.searchHits combines account and date bounds with participantIdentityId, personId, eventId, meetingSeriesId, projectId and tagId before hit pagination. Event and series are field predicates on the meeting, beside the others; the query itself is the messages query language (MEETING_HIT_QUERY: text, exact, from; OR, groups, NOT, phrases; query language, «Встречи»). A string is parsed; text that must not become syntax, such as a project name, is passed as meetingWordsQuery(text). from: attributes speech: the line's participant, through identity links to a person and all their identities. Participant identity and person filters match observed meeting membership and do not attribute speech. Project selection requires a confirmed, unanchored membership link to a live owner project. Tags and topics use explicit meeting taggings. Proposed project membership does not count.
searchMeetingHits from the services export also takes project, tag or topic names. It reuses the shared vocabulary's exact canonical-name, project-key and explicit-alias resolution; missing or ambiguous names fail with candidates instead of guessing. Results include the resolved name selections. It does not infer project membership from transcript words or write labels. Cursors bind the resolved IDs together with the account, query and dates. Before it reads, searchMeetingHits indexes what was saved since the last search (refreshMeetingIndex), in batches that each commit, so there is no separate index step; when the store's stemmers are unknown it indexes words only.
Providers mount addMeetingSearchCommand from the meetings CLI export: it adds search meetings under the host's search group (creating it when missing) and returns the command, so a host can add options and pick another source from them. Its search closure is fixed to the selected account and receives the request and every parsed option; its required pagingOf gives the page without --limit, the profile's defaults.limit. The optional meetingSearchTool (search_meetings) and callMeetingSearchTool(search, input, { limit, signal?, failure? }) from the meetings MCP export accept the same selectors, limit being the profile's defaults.limit as the messenger MCP lists take it, and so does callMeetingTool(store, name, input, { limit, failure?, source?, accountId?, signal?, timezone?, now?, offline? }) for meetings_list. Given the run's accountId (and its source), meetings_list and meeting_show read the service and the store as meetings list and show do, with the same backend argument and default, found_in on each item and the run's stop signal handed to the service; every tool then reads that account only, and an account_id naming another one is refused, never widened. A source without accountId is a configuration error. Without them the tools read the store, and a typed backend: "both" says in missing that the service was not asked. Hosts retain permission checks, connection lifecycle and output limits. A meetings_list that read the service may carry meta (complete: false with its issues, or the query's timezone): the host merges its run's meta into it, never replaces it, or a partial answer reads as complete. search_meetings answers the list envelope without meta, which the host adds, and so does meetings_list when it read only the store. In the search answer each item is a meeting_hit (ref, meeting, scope, id, excerpt, offset_ms, a transcript hit's language, line and lines_total, and match with corrections for a widened hit), the store's cursor is page.cursor with a page.next step, and passages left out because they changed since indexing are a missing entry with the meetings.search-again step (MEETING_STEPS, which a host lists beside its own steps). meetingHitsList turns a searchHits page into that answer for a host with its own search flow. addMeetingCommands hands write the running command; meetingAnswerBody(command, value) from @wirecat/cli-core/cli turns what it writes into the host's answer body: an envelope stays as it is, a listed() page becomes a list answer whose page.next step reruns the command, and any other value is one item, a packet's own next, missing and meta (meetings people) lifted onto the answer.
meetings show answers one meeting_details item; meetings transcript and meetings summary answer lists of meeting_transcript and meeting_summary (a cue's offset_ms, ISO times, meeting: references). No answer carries next_steps: SAVE_INSTRUCTION is the line for the host's MCP server instructions.
Search coverage remains explicit: an empty page does not prove the archive is complete, and pending indexing can hide matches. Discover participant identity candidates through bounded people lookup before selecting an identity filter. The separate readMeetingProjectDiscovery SDK reader supports word evidence before membership exists; mounting it in a host CLI/MCP remains separate work.
Hosts with alternate search sources can use createMeetingSearchCommand and
meetingHitSearchRequest(query, flags, limit, signal?) from /meetings/cli, limit being the profile's
defaults.limit, to reuse the grammar and validated word-request mapping, then route their source reports explicitly. Only a word MeetingSearchPage is passed
to meetingHitsList; an archive or meaning report has its own presentation contract. This avoids
casting an unrelated result into a word page. addMeetingSearchCommand remains the complete
word-only adapter. Both paths validate and observe cancellation before invoking the host read.
Pass meetingSearchArguments(query, flags) as the fourth meetingHitsList argument when composing
a CLI source router. Common CLI and MCP continuation repeats query, selection and read budget;
CLI dates are ISO timestamps and MCP dates remain epoch milliseconds. A pending-index retry
retains that selection but drops the old cursor to restart the search.
searchMeetingsCombined(store, embedder, query, request) from the services export ranks word hits and passage
vectors together. It resolves project, tag and topic names like searchMeetingHits, then reads two lists of at
most 200 each over the same selection of meetings (meetingSelectionSql): the word hits, and
meetingVectors.ranked — every vector of the embedder's model in the selection, compared in batches of 512 up to
maxChunks, with transcript text read only for the passages kept. Hits under the model's similarity floor
(meaningFloor) are dropped. The lists are merged by reciprocal rank fusion (k = 60). A transcript word hit whose
line lies inside a passage the meaning search found joins that passage: the item is cited by the word hit's line
(ref), keeps the passage as passage.first/passage.last, and says by: ["words", "meaning"]. Chat and summary
hits, and lines outside every found passage, stay word-only items.
A question — a question word at the start (что, какую, почему, did, why…), or a final ? — searches its content
words (questionTerms; the answer's words.from is question); other text is the meeting query language. Text the
language refuses is still asked by meaning: the word side is skipped and words.refused says why. On equal fused
scores a line that has the words ranks above a passage that only resembles the query
(measurement). from: and exact: apply to the word side only: a passage mixes speakers, so meaning has no speaker.
The cursor is an offset into one ranking, bound to the query, the filters and the model; a page past 200 hits of
either list has nothing more. coverage.meaningScanComplete is false when maxChunks stopped the scan; indexing and
archive completeness stay unknown, as in word search.
readMeetingStats(store, request) from the services export answers talk time, lines and words per speaker, and
meetings and talk time per week, over the meetings search would read (meetingSelectionSql; project, tag and
topic names resolve as in searchMeetingHits). A speaker is a linked person when the line's participant has one,
else the participant's identity, else the name the transcript gives; lines with none are unknown. Talk time is each
line's end less its start, so overlapping speech counts for everyone speaking. Each meeting counts its earliest current
transcript only, so a local transcript beside the provider's does not count twice; meetings without a transcript are
not counted. Weeks start on Monday in timeZone (UTC when not given). Words are counted from spaces in SQL; no
transcript text is read. More than maxRows lines (default and at most 500000) is an error, never a silent cut.
aggregateMeetingStats is the same arithmetic over rows a host already has.
readMeetingCounts(store, { by, timeZone, limit, ...selection }) answers how many meetings there were and how long
they took, per day, per week (its Monday) or per series, over the same selection, with meetingCountsItem as the
answer ({ by, meetings, minutes, mean_minutes, transcripts, rows: [{ key, name, meetings, minutes, mean_minutes, transcripts }], has_more }). It reads meetings alone, one row per meeting through meetings_by_time, never
transcript lines, so it has no row cap. A meeting's length is duration_ms, else its end less its start; a meeting
with no end counts in meetings but not in minutes, and mean_minutes is over the meetings that have a length
(null when none has). transcripts counts the meetings with a current transcript. Days and weeks are read in
timeZone (UTC when not given); a day or week with no meeting has no row, and a meeting with no start is in the
totals and its series but in no day or week. Under series a row is keyed series:<the series' external id> and
named by the series title (else its newest meeting's title), busiest by minutes first; every meeting outside a
series shares one row keyed NO_SERIES (no-series) with no name. limit (default 100) keeps the newest days or
weeks, oldest first, or the busiest series, and has_more says it left rows out. aggregateMeetingCounts is the
same arithmetic over meetings a host already has.
readCallStats(store, request) from the services export answers the call_stats entity over one account's meetings
that are phone calls, through the same selection as the meeting stats (meetingSelectionSql). The parts:
callOf(src/meetings/calls.ts) reads one stored meeting as a call:direction(incoming,outgoing,internal; Beeline'sINBOUNDandOUTBOUNDtoo),outcome,waitMs,talkMs,durationMs,placedBy,answeredByandrangfrom the metadata, the client from the participant whose role isclient, and employees from the extensions the metadata names (extension:<number>) or themanagerparticipants it does not name (identity:<id>). A key that is missing or of the wrong type isnull. A meeting with no direction, outcome or client is not a call and is counted innot_calls.aggregateCallStats(src/meetings/call-stats.ts) is the arithmetic, with no store: totals by direction and outcome, per employee, 24 hours and the days with a call in the zone, missed incoming calls (voicemail, busy, no answer) and their callbacks, and short calls. A callback is the client's next call within the window that is outgoing, or incoming and answered. A transferred call's talk counts for each employee who answered it. Counts are over the calls that give the field, andknownsays how many do. A key that no call of the selection gives is absent, never0ornull;nullis a value known to be empty, such as the mean wait when no incoming call was answered. Each missed call and its callback carry ameeting:ref.meetingCalls(src/store/sqlite/meeting-calls.ts) reads the selected meetings with their metadata and participants, at most 200000, oldest first.readCallStats(src/services/call-stats.ts) also reads the account's calls in the window afteruntil, or fromsinceto that window's end when the selection is narrowed to a person, so a callback by a colleague or after the selection counts.
addCallStatsCommand (src/cli/call-stats-command.ts) mounts stats calls show. Only a host whose meetings are calls
mounts it; nothing in the shared program does. Beeline keeps only recorded calls and writes no outcome, wait or talk,
so its report has known.outcome: 0 and no by_outcome, missed, talk or wait keys. --person-id selects the
calls whose participants link to the person: pbx keeps only the extensions that placed or answered a call as
participants, so a person's calls that only rang them are not selected.
addMeetingCombinedSearchCommand (src/cli/meeting-meaning-command.ts) mounts search meetings for a host of stored
meetings. Without --model it is the word search (searchMeetingHits); with --model it opens the embedder, splits
new transcripts and embeds the passages that have no vector for that model, then ranks words and meaning together
(searchMeetingsCombined). It returns the run, so a host's saved searches replay it. addMeetingEmbeddingCommand
mounts meetings embed under the host's meetings group: a preview of what has vectors, and --yes builds one
batch. Its --model defaults to the host's defaultModel(), which is chosenTextModel(env).id: a local model, so no
text leaves the computer. A remote model needs --model, --base-url and --dims together and is refused under the
root --offline. Both take meetingMeaning(store, accountId, { env }) from the services export; its load option
swaps the embedding runtime in tests.
zoom-cli still mounts its own copies (src/meeting-semantic-commands.ts, src/meeting-search-commands.ts); moving
it onto these is its own pull request.
A meeting is a tag target in the knowledge store ({ type: "meeting", id }), with the same taggings rows as every
other label, so search meetings --tag and tag: select the meetings that carry one. addMeetingTagsCommand
(src/cli/meeting-tags-command.ts) mounts tags add|remove|list for a host whose things to label are its meetings
(pbx, beeline), over meetingTags(store, accountId) from the services export. A messenger mounts its own tags.
tags add <tag...> --meeting <id>labels meetings by store id;--meetingrepeats. A meeting of another account isnot_found.tags add <tag...> --matching <query>labels every meeting of the account with at least one hit of thatsearch meetingsquery, reading every page of hits and indexing new transcripts first. It is idempotent: a rerun after new calls are transcribed changes only those, and the answer'schangedlists them. That is how marks stay current; nothing runs by itself. A mark stays when a new transcript of the call no longer says the words.tags removetakes the same targets.tags list [tag:<name>]lists this account's tagged meetings with all their tags, newest id last;knowledge.labelledwith an account reads only that account's meetings, never a deleted one.
A host mounts the search and the tags beside addCallStatsCommand:
addMeetingCombinedSearchCommand(program, {
words: async () => (query, request) => searchMeetingHits(store, query, { ...request, accountId }),
meaning: async () => meetingMeaning(store, accountId, { env }),
signal,
pagingOf,
output,
examples: […],
})
addMeetingEmbeddingCommand(program, {
meaning: async () => meetingMeaning(store, accountId, { env }),
defaultModel: () => chosenTextModel(env).id,
signal,
output,
examples: […],
})
addMeetingTagsCommand(program, {
read: async () => meetingTags(store, accountId),
examples: { add: […], remove: […], list: […] },
})readMeetingProjectDiscovery from the services export resolves one existing project through
knowledge.resolveVocabulary and reads canonical-name, key and explicit-alias word evidence.
Pass { vocabulary: store.knowledge, search: store.meetings }, a project name/key/alias and
MeetingProjectDiscoveryOptions from the meetings export. It never selects confirmed membership,
creates aliases/links or attributes transcript speech. Missing or ambiguous names fail before word reads.
One call reads one bounded word-search page for one name. limit and maxReadBytes keep the raw
search defaults (100 hits, 4 MiB); the separate maxVocabularyReadBytes defaults to 1 MiB, with
at most 10000 catalog entries. maxTerms defaults to 32 and cannot exceed 128. Names deduplicate
by the existing vocabulary normalizer, retaining their original labels and alias IDs. An excessive
catalog or name set fails visibly rather than silently dropping aliases.
The SDK packet records the selected account, canonical project, current name and source references,
plus association: "unconfirmed-word-evidence". The key may be an incidental word prefix; a match
is not proof of project membership. Repeated refs across names are the same evidence, explicitly
reported as possible duplicates. Person/participant/date/event/series/tag-ID constraints are
forwarded unchanged; project-ID membership filters and raw source cursors are refused here.
Resume with cursor: page.nextCursor even after an empty page while hasMore is true.
The opaque cursor retains within-name continuation before advancing to another name. It binds the
normalized project query, vocabulary fingerprint, term set, account and every evidence constraint.
Changing vocabulary or selection requires restarting; it is not an immutable multi-page snapshot.
Read budgets and result limits may change between pages. A missing source cursor or a foreign,
uncited or non-cue transcript reference fails instead of returning incomplete provenance as success.
This reader does not refresh indexes. Pending indexing and unknown archive/index completeness
remain explicit. Hosts may use the existing index-maintenance service through their injected
search port, and retain connection lifetime, cancellation and serialized-output limits. The packet
is a domain SDK result. The shared addMeetingProjectEvidenceCommand and
callMeetingProjectEvidenceTool adapters preserve its context/coverage in the registered
meeting_project_evidence item envelope, including a frozen selection query for continuation.
See the consumer interface for account binding and module ownership.
The raw discovery export itself mounts no command and performs no indexing.
The optional MeetingParticipantSearchStore.participantCandidates capability searches observed
participant names and emails in one selected account. SQLite scans names in stable ID order with
literal Unicode NFKC/case-insensitive matching; a query is not a wildcard or a person identity.
It reads only IDs, names, emails and the name of the person each participant's identity is linked to, checking
their UTF-8 byte sizes before hydration; a participant matches by that person's name too. Session
history, metadata and transcript text are excluded. Deleted meetings are excluded.
limit bounds matches (default 50, maximum 1000), scanLimit bounds observations examined (default
1000, maximum 10000), and maxReadBytes bounds name/email bytes (default 1 MiB, maximum 64 MiB).
The store packet may be empty and still have has_more: true. Resume with next_cursor, bound to the
selected account and normalized query. Its initial participant-ID upper bound prevents later
insertions from extending the same scan. Concurrent edits/deletions can still affect later pages;
the cursor is not a retained historical snapshot. Archive completeness remains unknown.
ambiguity.identity_ids and multiple_identities describe the current page only. Collect every
page before treating one name as a single candidate, inspect conflicting observations, and then
pass the chosen identity_id to meeting search. Repeated observations of one identity do not
constitute distinct people. A name match neither links a person nor identifies a transcript speaker.
The shared meetings people <query> CLI adds --limit, --scan-limit, --max-read-bytes and
--cursor; MCP meeting_people has equivalent limit, scan_limit, max_read_bytes and cursor.
Both use meetingPeople and the same store capability. Hosts retain output limits and connection
lifetime. Capable stores require a selected account instead of falling back to an unbounded global
lookup. Legacy adapters without the capability keep their old default result; explicitly
requesting paging fails instead of silently doing an unbounded read. Consumers need a published
SDK adoption before these new options become available.
Shared CLI/MCP participant reads adapt this store packet to the standard list envelope: page.limit,
page.has_more, optional page.cursor and a page.next step retaining the query and read budgets.
The host adds run metadata. Coverage and page-local ambiguity stay alongside the envelope.
A phone line's source (beeline, Asterisk) saves the other side of a call as the identity phone:<E.164> under its
own provider, and gives the number in SourceParticipant.phone too. The store reads that number with e164Of
(written with + or 00; anything else is left out) and keeps it in identities.phone, where the people matcher
reads every source's numbers.
When a call's number joins a person (NEED-2600). scanMatches joins the call's person and one other person when
exactly the two of them hold the number, one of the holders is keyed by the number itself (phone:<number>), and the
number is a mobile one (isMobilePhone). A landline only proposes the pair (score 0.7), since an office's main
line is everyone's who works there. Two CRM contacts on one number, or an organization holding it, join and propose
no one (sharedLine). A CRM's or a card's number written without +, such as 8 (912) 345-67-89, is read in the
store's phone_countries (Russian by default), and every number a CRM keeps in the identity's metadata phones
counts beside the first one in identities.phone. The whole scan runs in memo people scan and in memo sync.
Without memo. A meetings sync (pull) that saved callers with a number runs this phone rule alone for those
callers (linkPhones), so a call reaches its CRM contact with no people scan. It reads the numbers the store holds
once (55–70 ms for 20,000 CRM contacts, measured 2026-11-13), runs no other rule and moves no scan cursor, so memo's next scan still
looks at the callers by every rule. A linking failure is a warning of the sync, never its failure.
Where the link shows. Once linked, the call is the person's, with no new concept:
meetings show <id>andmeetings people <query>: each participant'sperson(person:<uid>and the person's name,nullwhen the identity is linked to no one);meetings peoplealso finds a participant by that name.contacts contextand the canonical person context:meetings[], the person's recorded meetings and calls, newest first, in the accounts the read may see (personMeetings).communicationsOf, so the deal and organization contexts: each call is a touch of kindmeetingwith itsmeeting:ref, and counts incounts.meetings; one held for a calendar event already counted counts once.deals showandleads showof a CRM copy:meetings[], the newest 10 of the people on it (never the owner), in the accounts of the CRM account's scope.
Each item carries ref (meeting:<account>/<meeting>), meeting_id, account (provider, account), title,
started_at, duration_ms, has_transcript, event and people. It opens with meetings show <meeting_id> or
meetings transcript <meeting_id> of the CLI and profile that own account.
Calls of the people on deal X. In one step: <crm> <profile> deals show deal:<id> lists them under meetings.
By hand, with the same result: deals show deal:<id> names its people (person:<uid>); memo's context person:<uid> lists each one's meetings (a messenger's contacts context person:<uid> does too, for a person with
an identity in that messenger); <phone-line> <profile> meetings transcript <meeting_id> reads one. The call's account and the CRM's must be in one scope (work): a read never crosses into
the other scope.
Read-budget, metadata, transcript-page and atomic cue-context contracts are exported from
@wirecat/cli-core/meetings, alongside participant lookup. Providers can implement these shared
interfaces through the meeting-module entry point. Existing store-entry type imports remain aliases.
Transcript hits from searchHits include ref, a retained meeting:<account>/<meeting>/<transcript>/<position> reference. Summary/chat hits reference the parent meeting and cannot serve as cue anchors. IDs and search cursors keep their existing meaning.
readMeetingHitContext from the services export accepts a cue reference and the authorized account ID. The optional transcriptContext store capability reads the anchor and both sides in one snapshot. Counts refer to actual cues, including sparse positions. Defaults are three before and three after, with at most 999 surrounding cues. max_read_bytes bounds stored text; boundary probes load only IDs, positions and sizes. No migration or index write is needed.
The anchor survives output clipping; if it cannot fit bytes, the read fails. Otherwise the closest contiguous cues on each side are kept within that budget. Coverage reports clipping, more content on each side and unknown archive completeness. Continuation references are inclusive anchors: repeating from one overlaps that cue. Explicit transcript references retain superseded revisions. expected_fingerprint checks a previously read anchor's cue fingerprint. Reading does not attribute anonymous speech or create records.
formatMeetingPassage renders an evidence or context packet as text or Markdown, retaining timestamps, speaker labels, references, revision and coverage. It escapes control characters and Markdown/HTML syntax and rejects output over its separate byte budget. Structured JSON keeps original text. Empty packets state that missing/clipped content does not prove absence. readMeetingPassage combines context and formatting.
Hosts opt into addMeetingPassageCommand from the meetings CLI export with a read closure fixed to their selected account. They retain connection lifetime, permissions and final stdout limits. Default output is text; global JSON/JSONL selects structured output. meetingPassageTool and callMeetingPassageTool from the meetings MCP export accept equivalent bounds and formats, never an account override, and keep the structured packet alongside display text. In a scheduled agent's run a host prints the passage text through passageForRun (@wirecat/cli-core/cli), and passes (result, format) => passageForRun(command, result, format) as callMeetingPassageTool's last argument, so cue text arrives between untrusted marks; meetings batch marks its report before the host formats it. Existing apps need a published producer and consumer integration before these commands become available.
An adopting host can expose this workflow with fictional references:
example search meetings "launch" --json
example meetings passage meeting:1/2/3/9 --before-n 3 --after-n 4 --format markdown
example meetings passage meeting:1/2/3/9 --before-n 0 --after-n 0 --jsonThe selected account is passed separately from the reference; a foreign reference fails before a read. CLI and MCP use one reader and formatter. A second synthetic provider needs no provider-specific branch.
For staged decisions and project work with atomic owner review, see reviewed meeting findings.