@wirecat/zoom-cli 0.55.0 → 0.57.0

package/dist/bundle/chunk-NN5B24KP.js

@@ -0,0 +1,1109 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  profileAccountKey,
+  profilePattern
+} from "./chunk-6P3YHT54.js";
+import {
+  checkCancelled
+} from "./chunk-A4ETXPMZ.js";
+import {
+  createMeetingSearchCommand,
+  meetingHitSearchRequest,
+  meetingSearchArguments,
+  meetingSearchMeta
+} from "./chunk-QLIB3PEC.js";
+import {
+  openOrdinaryFile
+} from "./chunk-ICSKEDPI.js";
+import {
+  Command,
+  FETCH,
+  LOCAL_READ,
+  NO_EFFECTS,
+  annotate,
+  answerSchema,
+  itemOf,
+  listOf,
+  metaNow,
+  metaOf,
+  overrideSharedContract
+} from "./chunk-MAEFLDHG.js";
+import {
+  parseDuration
+} from "./chunk-EOQFWJJD.js";
+import {
+  canonicalMeetingReference,
+  meetingHitsList,
+  parseMeetingReference,
+  validateMeetingContextChange,
+  validateMeetingHitSearch
+} from "./chunk-LXB6ONWC.js";
+import {
+  CliError,
+  createOutputBuffer,
+  errorObjectSchema,
+  isCliError,
+  jsonSchemaOf,
+  union
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// dist/local-transcription.js
+import { isAbsolute } from "node:path";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/speech/wav.js
+import { createHash } from "node:crypto";
+import { basename, resolve } from "node:path";
+var prepared = /* @__PURE__ */ new WeakMap();
+var checkCancelled2 = /* @__PURE__ */ __name((signal) => {
+  if (!signal?.aborted)
+    return;
+  if (signal.reason instanceof CliError)
+    throw signal.reason;
+  const timedOut = signal.reason instanceof Error && signal.reason.name === "TimeoutError";
+  throw new CliError(timedOut ? "timeout" : "cancelled", timedOut ? "command timed out" : "command cancelled");
+}, "checkCancelled");
+var invalid = /* @__PURE__ */ __name(() => {
+  throw new CliError("validation_error", "local transcription requires PCM16 mono/stereo WAV at 16 or 48 kHz; convert the media locally to PCM WAV first");
+}, "invalid");
+var validate = /* @__PURE__ */ __name((options) => {
+  if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1 || options.maxBytes > 4 * 1024 ** 3 || !Number.isSafeInteger(options.maxDurationMs) || options.maxDurationMs < 1 || options.maxDurationMs > 24 * 36e5)
+    throw new CliError("validation_error", "audio byte and duration budgets must be positive bounded integers");
+  checkCancelled2(options.signal);
+}, "validate");
+var exact = /* @__PURE__ */ __name(async (file, offset, size, signal) => {
+  const bytes2 = Buffer.alloc(size);
+  let read = 0;
+  while (read < size) {
+    checkCancelled2(signal);
+    const result = await file.read(bytes2, read, size - read, offset + read);
+    if (!result.bytesRead)
+      throw new CliError("validation_error", "WAV changed or was truncated while reading");
+    read += result.bytesRead;
+  }
+  return bytes2;
+}, "exact");
+var layoutOf = /* @__PURE__ */ __name(async (file, size, options) => {
+  if (size < 44 || size > options.maxBytes)
+    invalid();
+  const header = await exact(file, 0, 12, options.signal);
+  if (header.toString("ascii", 0, 4) !== "RIFF" || header.toString("ascii", 8, 12) !== "WAVE" || header.readUInt32LE(4) + 8 !== size)
+    invalid();
+  let format;
+  let data;
+  let at = 12;
+  let chunks = 0;
+  while (at < size) {
+    checkCancelled2(options.signal);
+    if (++chunks > 1024 || size - at < 8)
+      invalid();
+    const chunk = await exact(file, at, 8, options.signal);
+    const kind = chunk.toString("ascii", 0, 4);
+    const length = chunk.readUInt32LE(4);
+    const start = at + 8;
+    const next = start + length + length % 2;
+    if (next > size)
+      invalid();
+    if (kind === "fmt ") {
+      if (format || ![16, 18].includes(length))
+        invalid();
+      const bytes2 = await exact(file, start, length, options.signal);
+      const channels = bytes2.readUInt16LE(2);
+      const sampleRate = bytes2.readUInt32LE(4);
+      if (bytes2.readUInt16LE(0) !== 1 || ![1, 2].includes(channels) || ![16e3, 48e3].includes(sampleRate) || bytes2.readUInt16LE(14) !== 16 || bytes2.readUInt16LE(12) !== channels * 2 || bytes2.readUInt32LE(8) !== sampleRate * channels * 2 || length === 18 && bytes2.readUInt16LE(16) !== 0)
+        invalid();
+      format = { sampleRate, channels };
+    } else if (kind === "data") {
+      if (data || !length)
+        invalid();
+      data = { offset: start, size: length };
+    }
+    at = next;
+  }
+  if (!format || !data || data.size % (format.channels * 2) !== 0)
+    return invalid();
+  const frames = data.size / (format.channels * 2);
+  if (Math.ceil(frames * 1e3 / format.sampleRate) > options.maxDurationMs)
+    throw new CliError("validation_error", "WAV exceeds the configured duration limit");
+  return { ...format, dataOffset: data.offset, dataSize: data.size, frames };
+}, "layoutOf");
+var hashRange = /* @__PURE__ */ __name(async (file, hash, start, end, signal) => {
+  let at = start;
+  while (at < end) {
+    const bytes2 = await exact(file, at, Math.min(65536, end - at), signal);
+    hash.update(bytes2);
+    at += bytes2.length;
+  }
+}, "hashRange");
+var hashFile = /* @__PURE__ */ __name(async (file, size, signal) => {
+  const hash = createHash("sha256");
+  await hashRange(file, hash, 0, size, signal);
+  if ((await file.stat()).size !== size)
+    throw new CliError("validation_error", "WAV changed while verifying its content");
+  return hash.digest("hex");
+}, "hashFile");
+var preflightWavAudio = /* @__PURE__ */ __name(async (path, input) => {
+  const options = { ...input };
+  validate(options);
+  if (typeof path !== "string" || !path.trim() || /\0/.test(path))
+    throw new CliError("validation_error", "local audio file is required");
+  const absolute = resolve(path);
+  const file = await openOrdinaryFile(absolute);
+  try {
+    const stat = await file.stat({ bigint: true });
+    const size = Number(stat.size);
+    const layout = await layoutOf(file, size, options);
+    const contentHash = await hashFile(file, size, options.signal);
+    const after = await file.stat({ bigint: true });
+    if (stat.size !== after.size || stat.mtimeNs !== after.mtimeNs)
+      throw new CliError("validation_error", "WAV changed while preparing the transcription");
+    const media = Object.freeze({
+      id: createHash("sha256").update(basename(absolute)).digest("hex"),
+      contentHash,
+      size,
+      durationMs: Math.ceil(layout.frames * 1e3 / layout.sampleRate),
+      format: "wav",
+      sampleRate: layout.sampleRate,
+      channels: layout.channels
+    });
+    const plan = Object.freeze({ media });
+    prepared.set(plan, { path: absolute, dev: stat.dev, ino: stat.ino, layout });
+    return plan;
+  } finally {
+    await file.close();
+  }
+}, "preflightWavAudio");
+var openWavAudio = /* @__PURE__ */ __name(async (plan, input) => {
+  const options = { ...input };
+  validate(options);
+  const known = prepared.get(plan);
+  if (!known)
+    throw new CliError("validation_error", "audio plan was not prepared by this adapter");
+  const file = await openOrdinaryFile(known.path);
+  try {
+    const stat = await file.stat({ bigint: true });
+    if (stat.dev !== known.dev || stat.ino !== known.ino || Number(stat.size) !== plan.media.size)
+      throw new CliError("validation_error", "WAV identity changed before transcription");
+    const layout = await layoutOf(file, plan.media.size, options);
+    if (JSON.stringify(layout) !== JSON.stringify(known.layout) || await hashFile(file, plan.media.size, options.signal) !== plan.media.contentHash)
+      throw new CliError("validation_error", "WAV content changed before transcription");
+    let closed = false;
+    let consumed = false;
+    return {
+      async *windows() {
+        if (closed || consumed)
+          throw new CliError("configuration_error", "audio source can be consumed once before closing");
+        consumed = true;
+        const hash = createHash("sha256");
+        await hashRange(file, hash, 0, layout.dataOffset, options.signal);
+        const step = layout.sampleRate / 16e3;
+        for (let frame = 0; frame < layout.frames; ) {
+          checkCancelled2(options.signal);
+          const count = Math.min(layout.sampleRate * 30, layout.frames - frame);
+          const bytes2 = await exact(file, layout.dataOffset + frame * layout.channels * 2, count * layout.channels * 2, options.signal);
+          hash.update(bytes2);
+          const samples = new Float32Array(Math.floor(count / step));
+          for (let index = 0; index < samples.length; index++) {
+            let sum = 0;
+            for (let offset = 0; offset < step; offset++)
+              for (let channel = 0; channel < layout.channels; channel++)
+                sum += bytes2.readInt16LE(((index * step + offset) * layout.channels + channel) * 2);
+            samples[index] = sum / (32768 * step * layout.channels);
+          }
+          const startMs = Math.floor(frame * 1e3 / layout.sampleRate);
+          frame += count;
+          if (samples.length)
+            yield { startMs, endMs: Math.ceil(frame * 1e3 / layout.sampleRate), samples };
+        }
+        await hashRange(file, hash, layout.dataOffset + layout.dataSize, plan.media.size, options.signal);
+        if (hash.digest("hex") !== plan.media.contentHash || (await file.stat()).size !== plan.media.size)
+          throw new CliError("validation_error", "WAV changed during recognition; no transcript may be stored");
+      },
+      async close() {
+        if (!closed) {
+          closed = true;
+          await file.close();
+        }
+      }
+    };
+  } catch (error) {
+    await file.close();
+    throw error;
+  }
+}, "openWavAudio");
+
+// dist/media-decode.js
+import { execFile } from "node:child_process";
+import { mkdtemp, open, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+var readyWav = /* @__PURE__ */ __name(async (file) => {
+  const handle = await open(file, "r").catch(() => {
+    throw new CliError("not_found", "the audio or video file could not be opened");
+  });
+  try {
+    const head = Buffer.alloc(4096);
+    const { bytesRead } = await handle.read(head, 0, head.length, 0);
+    if (bytesRead < 12 || head.toString("ascii", 0, 4) !== "RIFF" || head.toString("ascii", 8, 12) !== "WAVE")
+      return false;
+    for (let at = 12; at + 8 <= bytesRead; at += 8 + head.readUInt32LE(at + 4) + head.readUInt32LE(at + 4) % 2) {
+      if (head.toString("ascii", at, at + 4) !== "fmt " || at + 24 > bytesRead)
+        continue;
+      const format = head.readUInt16LE(at + 8);
+      const channels = head.readUInt16LE(at + 10);
+      const rate = head.readUInt32LE(at + 12);
+      const bits = head.readUInt16LE(at + 22);
+      return format === 1 && bits === 16 && (channels === 1 || channels === 2) && (rate === 16e3 || rate === 48e3);
+    }
+    return false;
+  } finally {
+    await handle.close();
+  }
+}, "readyWav");
+var wavFor = /* @__PURE__ */ __name(async (file, options = {}) => {
+  if (await readyWav(file))
+    return { path: file, decoded: false, release: /* @__PURE__ */ __name(async () => {
+    }, "release") };
+  const directory = await mkdtemp(join(tmpdir(), "zm-decode-"));
+  const release = /* @__PURE__ */ __name(() => rm(directory, { recursive: true, force: true }), "release");
+  const path = join(directory, "audio.wav");
+  const args = ["-nostdin", "-hide_banner", "-loglevel", "error", "-i", file, "-vn", "-ac", "1", "-ar", "16000"];
+  args.push("-c:a", "pcm_s16le", "-fflags", "+bitexact", "-flags:a", "+bitexact", "-map_metadata", "-1", path);
+  try {
+    await new Promise((resolve2, reject) => execFile(options.ffmpeg ?? "ffmpeg", args, { signal: options.signal, maxBuffer: 1024 * 1024 }, (error, _out, err) => {
+      if (!error)
+        return resolve2();
+      if (error.code === "ENOENT")
+        return reject(new CliError("configuration_error", "decoding a recording that is not WAV needs ffmpeg on PATH; zm does not install it"));
+      if (options.signal?.aborted)
+        return reject(new CliError("cancelled", "decoding was cancelled"));
+      reject(new CliError("validation_error", `ffmpeg could not decode the file: ${String(err).trim().slice(0, 300)}`));
+    }));
+    return { path, decoded: true, release };
+  } catch (error) {
+    await release();
+    throw error;
+  }
+}, "wavFor");
+
+// dist/local-transcription.js
+var validateLocalTranscriptionOptions = /* @__PURE__ */ __name((input) => {
+  const options = { ...input };
+  if (typeof options.model !== "string" || !options.model.trim() || options.model.length > 200 || /[\0\r\n]/.test(options.model))
+    throw new CliError("validation_error", "local transcription requires an explicit speech model");
+  if (options.modelsDirectory !== void 0 && (typeof options.modelsDirectory !== "string" || !isAbsolute(options.modelsDirectory) || options.modelsDirectory.length > 4096 || /[\0\r\n]/.test(options.modelsDirectory)))
+    throw new CliError("validation_error", "speech model directory must be an absolute bounded path");
+  for (const [value, max, label] of [
+    [options.maxBytes, 4 * 1024 ** 3, "media bytes"],
+    [options.maxDurationMs, 24 * 36e5, "media duration"],
+    [options.maxSegments, 1e5, "segment count"],
+    [options.maxTextBytes, 64 * 1024 ** 2, "transcript text bytes"]
+  ])
+    if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1 || value > max))
+      throw new CliError("validation_error", `invalid ${label} budget`);
+  for (const value of [options.apply, options.dryRun])
+    if (value !== void 0 && typeof value !== "boolean")
+      throw new CliError("validation_error", "transcription apply and dry-run options must be booleans");
+  return options;
+}, "validateLocalTranscriptionOptions");
+var compactLocalTranscriptionReceipt = /* @__PURE__ */ __name((receipt) => {
+  const append = receipt.append;
+  if (!receipt.applied || !append || !Number.isSafeInteger(append.meeting.meeting.id) || append.meeting.meeting.id < 1)
+    throw new CliError("outcome_unknown", "transcription did not return a usable committed acknowledgement");
+  return {
+    applied: true,
+    accountId: receipt.accountId,
+    externalId: receipt.externalId,
+    meetingId: append.meeting.meeting.id,
+    created: append.created,
+    insertedTranscripts: append.insertedTranscripts,
+    replayedTranscripts: append.replayedTranscripts,
+    supersededTranscripts: append.supersededTranscripts,
+    segments: receipt.segments,
+    mediaSha256: receipt.media.contentHash,
+    engine: receipt.media.recognition.engine,
+    model: receipt.media.recognition.model,
+    modelVersion: receipt.media.recognition.version ?? null,
+    timing: receipt.media.recognition.timing ?? "recognition-segments"
+  };
+}, "compactLocalTranscriptionReceipt");
+var engineFailure = /* @__PURE__ */ __name(async (model, work) => {
+  try {
+    return await work();
+  } catch (error) {
+    if (error instanceof Error)
+      throw error;
+    throw new CliError("configuration_error", `the speech engine could not run ${model}; \`zm models download ${model}\` checks its files and repairs them`);
+  }
+}, "engineFailure");
+var loadSpeech = /* @__PURE__ */ __name(async () => {
+  const speech = await import("./speech-5JOXLYDA.js");
+  return { describe: speech.localSpeechRecognitionModel, open: speech.openLocalSpeechRecognizer };
+}, "loadSpeech");
+var createWavTranscriptionSource = /* @__PURE__ */ __name((file, options) => {
+  const selected = { ...options, ...options.env ? { env: { ...options.env } } : {} };
+  let plan;
+  let recognition;
+  let speech;
+  return {
+    async describe(context) {
+      checkCancelled(context.signal);
+      speech = await (selected.speech ?? loadSpeech)();
+      recognition = Object.freeze({ ...speech.describe(selected.model) });
+      plan = await preflightWavAudio(file, context);
+      return Object.freeze({
+        ...plan.media,
+        recognition: Object.freeze({
+          engine: recognition.engine,
+          model: recognition.model,
+          version: recognition.version,
+          timing: "fixed-windows"
+        })
+      });
+    },
+    async *segments(media, context) {
+      if (!plan || !recognition || !speech || media.contentHash !== plan.media.contentHash || media.id !== plan.media.id || media.size !== plan.media.size || media.durationMs !== plan.media.durationMs || media.recognition.engine !== recognition.engine || media.recognition.model !== recognition.model || media.recognition.version !== recognition.version)
+        throw new CliError("validation_error", "transcription media descriptor does not match its prepared audio and model");
+      const audio = await openWavAudio(plan, context);
+      let model;
+      try {
+        checkCancelled(context.signal);
+        const port = speech;
+        const chosen = recognition.model;
+        model = await engineFailure(chosen, () => port.open(chosen, {
+          directory: selected.modelsDirectory,
+          env: selected.env,
+          signal: context.signal
+        }));
+        if (model.engine !== recognition.engine || model.model !== recognition.model || model.version !== recognition.version)
+          throw new CliError("validation_error", "installed speech recognizer changed after the media preview");
+        for await (const window of audio.windows()) {
+          checkCancelled(context.signal);
+          const recognizer = model;
+          const text = await engineFailure(recognition.model, () => recognizer.recognize(window.samples, { signal: context.signal }));
+          checkCancelled(context.signal);
+          yield { startMs: window.startMs, endMs: window.endMs, text };
+        }
+      } finally {
+        try {
+          await model?.close();
+        } finally {
+          await audio.close();
+        }
+      }
+    }
+  };
+}, "createWavTranscriptionSource");
+var createLocalTranscriptionCapabilities = /* @__PURE__ */ __name((store, input = {}) => {
+  const accountId = store.accountId;
+  if (!Number.isSafeInteger(accountId) || accountId < 1)
+    throw new CliError("validation_error", "local transcription requires a selected existing account");
+  const options = { ...input, ...input.env ? { env: { ...input.env } } : {} };
+  const resolveMeeting = store.resolveMeeting.bind(store);
+  const appendTranscriptsWithReceipt = store.appendTranscriptsWithReceipt.bind(store);
+  return {
+    async transcribe(reference, file, raw) {
+      const request = validateLocalTranscriptionOptions(raw);
+      checkCancelled(request.signal);
+      const resolved = await resolveMeeting(reference, request.signal);
+      const found = resolved && {
+        accountId: resolved.accountId,
+        meetingId: resolved.meetingId,
+        externalId: resolved.externalId
+      };
+      if (!found || found.accountId !== accountId || !Number.isSafeInteger(found.meetingId) || found.meetingId < 1 || typeof found.externalId !== "string" || !found.externalId.trim())
+        throw new CliError("not_found", "meeting was not found in the selected account");
+      const target = Object.freeze({ accountId, externalId: found.externalId, now: options.now?.() ?? Date.now() });
+      const audio = await wavFor(file, { signal: request.signal });
+      try {
+        const source = createWavTranscriptionSource(audio.path, {
+          model: request.model,
+          modelsDirectory: request.modelsDirectory,
+          env: options.env,
+          speech: options.speech
+        });
+        const { transcribeMeeting } = await import("./meetings-IBPI4MM4.js");
+        return await transcribeMeeting(source, {
+          appendTranscriptsWithReceipt(value) {
+            if (value.accountId !== accountId || value.externalId !== target.externalId)
+              throw new CliError("validation_error", "transcription append must retain its selected target");
+            return appendTranscriptsWithReceipt(value);
+          }
+        }, target, request);
+      } finally {
+        await audio.release();
+      }
+    }
+  };
+}, "createLocalTranscriptionCapabilities");
+
+// dist/meeting-context.js
+var integer = /* @__PURE__ */ __name((value, min, max) => Number.isSafeInteger(value) && value >= min && value <= max, "integer");
+var validateEvidenceOptions = /* @__PURE__ */ __name((options = {}) => {
+  if (!integer(options.cues ?? 100, 1, 1e3) || !integer(options.bytes ?? 65536, 2, 4194304) || !integer(options.maxReadBytes ?? 4194304, 1, 67108864) || !integer(options.maxTranscriptPages ?? 100, 1, 1e3) || options.afterTranscriptId !== void 0 && !integer(options.afterTranscriptId, 1, Number.MAX_SAFE_INTEGER) || options.after !== void 0 && options.afterTranscriptId !== void 0 || options.after !== void 0 && (typeof options.after !== "string" || !options.after.trim()))
+    throw new CliError("validation_error", "meeting evidence requires 1\u20131000 cues and 2\u20134194304 bytes");
+}, "validateEvidenceOptions");
+var validatePersonContext = /* @__PURE__ */ __name((person, options = {}) => {
+  validateEvidenceOptions(options);
+  if (typeof person !== "string" || !/^person:[1-9]\d*$/.test(person) || !integer(Number(person.slice(7)), 1, Number.MAX_SAFE_INTEGER) || !integer(options.meetings ?? 10, 1, 100) || !integer(options.scanLimit ?? 1e3, 1, 1e3) || options.since !== void 0 && !Number.isSafeInteger(options.since))
+    throw new CliError("validation_error", "person meeting context requires person:<positive ID> and valid bounded limits");
+}, "validatePersonContext");
+var validateTaskKind = /* @__PURE__ */ __name((kind) => {
+  if (!["question", "request", "mention", "promise"].includes(kind))
+    throw new CliError("validation_error", "task kind must be question, request, mention or promise");
+  return kind;
+}, "validateTaskKind");
+var validateTaskProposal = /* @__PURE__ */ __name((value) => {
+  if (typeof value !== "object" || value === null || !("applied" in value) || value.applied !== false || !("persistence" in value) || value.persistence !== "proposal-only")
+    throw new CliError("invalid_response", "task proposal must be unapplied and proposal-only");
+}, "validateTaskProposal");
+var loadProducer = /* @__PURE__ */ __name(async () => {
+  const [domain, services] = await Promise.all([import("./dist-IBNHCQXT.js"), import("./services-KC5KQFBS.js")]);
+  return { ...services, ...domain };
+}, "loadProducer");
+var createMeetingContextCapabilities = /* @__PURE__ */ __name((store, meetings, accountId, load = loadProducer) => {
+  if (!integer(accountId, 1, Number.MAX_SAFE_INTEGER))
+    throw new CliError("validation_error", "meeting context requires a selected positive account ID");
+  const ownedReference = /* @__PURE__ */ __name((api, reference) => {
+    if (api.parseMeetingReference(reference).accountId !== accountId)
+      throw new CliError("not_found", "meeting reference is unavailable for the selected account");
+    return api.canonicalMeetingReference(reference);
+  }, "ownedReference");
+  return {
+    passage: /* @__PURE__ */ __name(async (reference, options = {}) => {
+      checkCancelled(options.signal);
+      const api = await load();
+      checkCancelled(options.signal);
+      const owned = ownedReference(api, reference);
+      const result = await api.readMeetingPassage(meetings, accountId, owned, options);
+      checkCancelled(options.signal);
+      return result;
+    }, "passage"),
+    evidence: /* @__PURE__ */ __name(async (reference, options = {}) => {
+      validateEvidenceOptions(options);
+      checkCancelled(options.signal);
+      const api = await load();
+      checkCancelled(options.signal);
+      const owned = ownedReference(api, reference);
+      const result = await api.readMeetingEvidence(meetings, accountId, owned, {
+        cues: options.cues,
+        bytes: options.bytes,
+        signal: options.signal,
+        after: options.after === void 0 ? void 0 : ownedReference(api, options.after),
+        afterTranscriptId: options.afterTranscriptId,
+        maxReadBytes: options.maxReadBytes,
+        maxTranscriptPages: options.maxTranscriptPages
+      });
+      checkCancelled(options.signal);
+      return result;
+    }, "evidence"),
+    personContext: /* @__PURE__ */ __name(async (person, options = {}) => {
+      validatePersonContext(person, options);
+      checkCancelled(options.signal);
+      const api = await load();
+      checkCancelled(options.signal);
+      const personStore = {
+        people: store.people,
+        involvements: store.involvements,
+        meetings
+      };
+      const result = await api.personMeetingContext(personStore, person, {
+        accountIds: [accountId],
+        meetings: options.meetings,
+        cues: options.cues,
+        bytes: options.bytes,
+        scanLimit: options.scanLimit,
+        since: options.since,
+        signal: options.signal
+      });
+      checkCancelled(options.signal);
+      return result;
+    }, "personContext"),
+    taskProposal: /* @__PURE__ */ __name(async (reference, kind, signal) => {
+      validateTaskKind(kind);
+      checkCancelled(signal);
+      const api = await load();
+      checkCancelled(signal);
+      const owned = ownedReference(api, reference);
+      const result = await api.proposeMeetingTask(meetings, accountId, owned, kind);
+      checkCancelled(signal);
+      validateTaskProposal(result);
+      return result;
+    }, "taskProposal")
+  };
+}, "createMeetingContextCapabilities");
+
+// dist/meeting-integration.js
+var integrationReference = /* @__PURE__ */ __name((reference) => {
+  const parsed = parseMeetingReference(reference);
+  if (parsed.transcriptId !== void 0)
+    throw new CliError("validation_error", "this operation requires a root meeting reference");
+  return { parsed, reference: canonicalMeetingReference(reference) };
+}, "integrationReference");
+
+// dist/answers.js
+import { randomUUID } from "node:crypto";
+var answerSchema2 = answerSchema();
+var outputSchema = { ...jsonSchemaOf(union([answerSchema2, errorObjectSchema])) };
+var toolAnswerSchema = { ...outputSchema, type: "object" };
+var readMetadata = /* @__PURE__ */ __name((now = Date.now, runId = randomUUID()) => {
+  const started = now();
+  return () => metaNow({ run_id: runId, duration_ms: Math.max(0, Math.round(now() - started)) });
+}, "readMetadata");
+
+// dist/execution.js
+var duration = /* @__PURE__ */ __name((text, source = "duration") => {
+  const value = parseDuration(text, source);
+  if (!Number.isSafeInteger(value) || value > 2147483647)
+    throw new CliError("validation_error", "duration exceeds the supported timer range");
+  return value;
+}, "duration");
+var bytes = /* @__PURE__ */ __name((text) => {
+  if (!/^\d+$/.test(text) || !Number.isSafeInteger(Number(text)))
+    throw new CliError("validation_error", "expected a nonnegative whole byte count");
+  return Number(text);
+}, "bytes");
+var longRunning = /* @__PURE__ */ new WeakSet();
+var runsLong = /* @__PURE__ */ __name((command) => {
+  longRunning.add(command);
+  return command;
+}, "runsLong");
+var commandDeadline = /* @__PURE__ */ __name((action) => {
+  const { lifetime } = metaOf(action);
+  if (lifetime === "persistent")
+    return void 0;
+  if (lifetime === "interactive")
+    return 3e5;
+  return longRunning.has(action) ? 36e5 : 3e4;
+}, "commandDeadline");
+var sharedExecution = /* @__PURE__ */ __name((action, environment, now, runId) => {
+  const max = action.optsWithGlobals().maxOutputBytes;
+  return {
+    action,
+    signal: environment.signal,
+    meta: readMetadata(now, runId),
+    output: createOutputBuffer({ maxOutputBytes: max === void 0 ? void 0 : Number(max) })
+  };
+}, "sharedExecution");
+
+// dist/meeting-semantic-commands.js
+var bounded = /* @__PURE__ */ __name((value, maximum) => value === void 0 || Number.isSafeInteger(value) && value > 0 && value <= maximum, "bounded");
+var validateMeetingModel = /* @__PURE__ */ __name((options) => {
+  if (typeof options.model !== "string" || !options.model.trim() || options.model.length > 1e3)
+    throw new CliError("validation_error", "select an explicit embedding model");
+  if (options.baseUrl === void 0) {
+    if (options.dims !== void 0)
+      throw new CliError("validation_error", "dimensions require an explicit remote base URL");
+    return;
+  }
+  let url;
+  try {
+    url = new URL(options.baseUrl);
+  } catch {
+    throw new CliError("validation_error", "embedding base URL must be an HTTP or HTTPS URL");
+  }
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !/^[\w./:-]{1,200}$/.test(options.model) || options.dims === void 0 || !bounded(options.dims, 8192))
+    throw new CliError("validation_error", "remote embeddings require an HTTP base URL without credentials and explicit dimensions");
+}, "validateMeetingModel");
+var validateMeetingSemantic = /* @__PURE__ */ __name((query, options) => {
+  validateMeetingModel(options);
+  if (typeof query !== "string" || !query.trim() || Buffer.byteLength(query, "utf8") > 65536 || !bounded(options.limit, 1e3) || !bounded(options.maxChunks, 1e5) || !bounded(options.maxRows, 1e5) || !bounded(options.maxTextBytes, 64 * 1024 * 1024))
+    throw new CliError("validation_error", "meeting semantic search requires a nonempty bounded query and positive limits");
+}, "validateMeetingSemantic");
+var validateMeetingEmbeddings = /* @__PURE__ */ __name((options) => {
+  validateMeetingModel(options);
+  if (!bounded(options.limit, 1e3) || !bounded(options.afterTranscriptId, Number.MAX_SAFE_INTEGER) || !bounded(options.maxRows, 1e5) || !bounded(options.maxTextBytes, 64 * 1024 * 1024) || options.afterHash !== void 0 && !/^[a-f0-9]{64}$/.test(options.afterHash))
+    throw new CliError("validation_error", "meeting embedding generation requires valid bounded limits and cursors");
+}, "validateMeetingEmbeddings");
+var addMeetingEmbeddingCommand = /* @__PURE__ */ __name((program, deps) => {
+  const meetings = program.commands.find((command) => command.name() === "meetings");
+  if (!meetings)
+    throw new CliError("configuration_error", "meeting command group is unavailable");
+  const model = /* @__PURE__ */ __name((command) => command.requiredOption("--model <model>", "embedding model: an installed local one, or one served at --base-url").option("--base-url <url>", "remote embedding service; OpenAI reads OPENAI_API_KEY").option("--dims <n>", "vector size the remote service returns, in dimensions", bytes), "model");
+  const budget = /* @__PURE__ */ __name((command) => command.option("--limit <n>", "how many results or items in one batch, 1 through 1000", bytes).option("--max-rows <n>", "most transcript lines to read, 1 through 100000", bytes).option("--max-text-bytes <bytes>", "most transcript text to read, in bytes (default 4 MiB)", bytes), "budget");
+  annotate(budget(model(meetings.command("embeddings").description("preview building meeting vectors; --yes builds one batch"))).option("--after-transcript-id <id>", "continue splitting transcripts after this one", bytes).option("--after-hash <hash>", "continue embedding after this passage").option("--yes", "split transcripts and build their vectors; otherwise only preview").action(async (options) => {
+    validateMeetingEmbeddings(options);
+    if (options.baseUrl !== void 0 && deps.offline())
+      throw new CliError("configuration_error", "remote embeddings require network access; remove --offline");
+    const api = await deps.capabilities();
+    const result = await api.generate({ ...options, signal: deps.signal() });
+    if (options.yes)
+      await deps.receipt(itemOf(result));
+    else
+      deps.output(itemOf(result));
+  }), { origin: "handwritten", effects: FETCH, examples: ["zm personal meetings embeddings --model e5-small --json"] });
+}, "addMeetingEmbeddingCommand");
+
+// dist/meeting-search-commands.js
+var FLAG = {
+  meetingId: "--meeting-id",
+  identityId: "--identity-id",
+  personId: "--person-id",
+  eventId: "--event-id",
+  seriesId: "--series-id",
+  project: "--project",
+  tag: "--tag",
+  topicName: "--topic-name",
+  sinceTime: "--since-time",
+  untilTime: "--until-time",
+  cursor: "--cursor",
+  maxReadBytes: "--max-read-bytes",
+  model: "--model",
+  baseUrl: "--base-url",
+  dims: "--dims",
+  maxChunks: "--max-chunks",
+  maxRows: "--max-rows",
+  maxTextBytes: "--max-text-bytes"
+};
+var refuse = /* @__PURE__ */ __name((options, keys, mode) => {
+  const given = keys.filter((key) => options[key] !== void 0).map((key) => FLAG[key]);
+  if (given.length)
+    throw new CliError("validation_error", `${given.join(", ")} do not apply ${mode}`);
+}, "refuse");
+var recordingHit = /* @__PURE__ */ __name((directory) => (match) => {
+  const meetingStart = Date.parse(match.meeting.startedAt ?? "");
+  const assetStart = Date.parse(match.asset.startedAt ?? "");
+  const lead = assetStart - meetingStart;
+  return {
+    kind: "meeting",
+    ref: `recording:${match.asset.id}/${match.position}`,
+    provider: "zoom",
+    account: directory,
+    title: match.meeting.title,
+    timestamp: Number.isFinite(meetingStart) ? new Date(meetingStart).toISOString() : null,
+    excerpt: match.text,
+    sender_name: match.speaker,
+    offset_ms: match.startMs + (Number.isFinite(lead) && lead > 0 ? lead : 0)
+  };
+}, "recordingHit");
+var combinedList = /* @__PURE__ */ __name((found, limit, args) => listOf("search meetings", {
+  items: found.items.map((hit) => ({
+    ref: hit.ref,
+    meeting: hit.ref.split("/").slice(0, 2).join("/"),
+    scope: hit.scope,
+    excerpt: hit.text,
+    offset_ms: hit.startMs,
+    by: hit.by,
+    score: hit.score,
+    ...hit.passage ? { passage: hit.passage } : {},
+    ...hit.match ? { match: hit.match } : {},
+    ...hit.corrections ? { corrections: hit.corrections } : {},
+    source: {
+      title: hit.source.title,
+      started_at: hit.source.startedAt === null ? null : new Date(hit.source.startedAt).toISOString(),
+      url: hit.source.url
+    }
+  })),
+  limit,
+  has_more: found.hasMore,
+  paging: "cursor",
+  ...found.nextCursor ? { cursor: found.nextCursor } : {},
+  args,
+  missing: [
+    ...found.coverage.meaningScanComplete ? [] : [{ field: "items", why: `meaning compared only ${found.coverage.scanned} passages; raise --max-chunks` }],
+    ...found.words.refused ? [{ field: "items", why: `found by meaning only: ${found.words.refused}` }] : []
+  ]
+}), "combinedList");
+var withMeaningOptions = /* @__PURE__ */ __name((command) => overrideSharedContract(command, "Zoom explicitly extends meeting search with semantic ranking and bounded embedding-provider controls.", (one) => {
+  one.description("find words in stored meetings, or by meaning with --model").option("--model <model>", "rank words and meaning together with this embedding model, building missing vectors first").option("--base-url <url>", "remote embedding service for --model; OpenAI reads OPENAI_API_KEY").option("--dims <n>", "vector size the remote service returns, in dimensions", bytes).option("--max-chunks <n>", "by meaning: most stored passages to compare (default 10000)", bytes).option("--max-rows <n>", "by meaning: most transcript lines to read, 1 through 100000", bytes).option("--max-text-bytes <bytes>", "by meaning: most transcript text to read (default 4 MiB)", bytes);
+}), "withMeaningOptions");
+var meetingSearchDefinition = /* @__PURE__ */ __name(() => {
+  const program = new Command();
+  const command = withMeaningOptions(createMeetingSearchCommand(program));
+  return { program, command };
+}, "meetingSearchDefinition");
+var addMeetingSearchCommands = /* @__PURE__ */ __name((program, deps) => {
+  const execute = /* @__PURE__ */ __name(async (query, options) => {
+    const request = meetingHitSearchRequest(query, options, deps.signal());
+    if (options.model !== void 0) {
+      refuse(options, ["maxReadBytes"], "to a search by meaning");
+      const { limit, after, maxReadBytes: _bytes, signal, ...selection } = request;
+      const meaning = {
+        model: options.model,
+        baseUrl: options.baseUrl,
+        dims: options.dims,
+        limit: limit ?? 20,
+        maxChunks: options.maxChunks,
+        after,
+        selection,
+        maxRows: options.maxRows,
+        maxTextBytes: options.maxTextBytes,
+        buildMissing: true,
+        signal
+      };
+      validateMeetingSemantic(query, meaning);
+      if (meaning.baseUrl !== void 0 && deps.offline())
+        throw new CliError("configuration_error", "remote embeddings require network access; remove --offline");
+      return combinedList(await (await deps.meaning()).search(query, meaning), meaning.limit, meetingSearchArguments(query, options));
+    }
+    refuse(options, ["baseUrl", "dims", "maxChunks", "maxRows", "maxTextBytes"], "without --model");
+    return meetingHitsList(await (await deps.words())(query, request), request.limit ?? 100, "search meetings", meetingSearchArguments(query, options), meetingSearchMeta(options));
+  }, "execute");
+  const command = withMeaningOptions(createMeetingSearchCommand(program)).action(async (query, options) => {
+    deps.output(await execute(query, options));
+  });
+  overrideSharedContract(command, "Zoom meeting search may build missing embeddings, so its effects and examples include that explicit mode.", (one) => {
+    annotate(one, {
+      origin: "handwritten",
+      effects: FETCH,
+      examples: [
+        'zm personal search meetings "example plan" --since-time 2026-09-01 --json',
+        'zm personal search meetings "example plan" --model e5-small --json'
+      ]
+    });
+  });
+  const search = program.commands.find((child) => child.name() === "search") ?? annotate(program.command("search"), { effects: NO_EFFECTS });
+  const recordings = search.command("recordings").description("find words in the transcripts of a downloaded archive folder, before any import").argument("<directory>", "archive folder").argument("<query...>", "words to find as one phrase, ignoring case").option("--limit <n>", "how many hits, 1 through 1000 (default 100)", bytes).action(async (directory, words, options) => {
+    const found = await deps.archive(directory, words.join(" "), { limit: options.limit, signal: deps.signal() });
+    deps.output({
+      items: found.items.map(recordingHit(directory)),
+      page: { mode: "page", limit: found.limit, has_more: found.hasMore }
+    });
+  });
+  annotate(recordings, {
+    origin: "handwritten",
+    effects: LOCAL_READ,
+    output: { entity: "hit" },
+    examples: ['zm personal search recordings ./zoom-archive "example plan" --limit 100 --offline --json']
+  });
+  return execute;
+}, "addMeetingSearchCommands");
+
+// dist/meeting-semantic.js
+var loadProducer2 = /* @__PURE__ */ __name(async () => import("./services-KC5KQFBS.js"), "loadProducer");
+var createMeetingSemanticCapabilities = /* @__PURE__ */ __name((store, accountId, options = {}) => {
+  if (!Number.isSafeInteger(accountId) || accountId < 1)
+    throw new CliError("validation_error", "meeting vectors require a selected positive account ID");
+  const load = options.load ?? loadProducer2;
+  const choice = /* @__PURE__ */ __name((api, input) => input.baseUrl === void 0 ? input.model : { remote: api.createMeetingRemoteModel({ model: input.model, baseUrl: input.baseUrl, dims: input.dims }) }, "choice");
+  const budget = /* @__PURE__ */ __name((input) => ({
+    maxRows: input.maxRows,
+    maxTextBytes: input.maxTextBytes,
+    signal: input.signal
+  }), "budget");
+  const buildMissing = /* @__PURE__ */ __name(async (api, embedder, input) => {
+    let afterTranscriptId;
+    for (; ; ) {
+      checkCancelled(input.signal);
+      const page = await store.meetingVectors.rebuild({ accountId, limit: 1e3, afterTranscriptId, ...budget(input) });
+      if (!page.hasMore || page.nextTranscriptId === void 0)
+        break;
+      afterTranscriptId = page.nextTranscriptId;
+    }
+    let afterHash;
+    for (; ; ) {
+      checkCancelled(input.signal);
+      const batch = await api.applyMeetingEmbedding(store.meetingVectors, accountId, embedder, {
+        afterHash,
+        ...budget(input)
+      });
+      if (!batch.hasMore || batch.nextHash === void 0)
+        return;
+      afterHash = batch.nextHash;
+    }
+  }, "buildMissing");
+  return {
+    search: /* @__PURE__ */ __name(async (query, input) => {
+      validateMeetingSemantic(query, input);
+      checkCancelled(input.signal);
+      const api = await load();
+      checkCancelled(input.signal);
+      const selected = choice(api, input);
+      const embedder = await api.openMeetingEmbedder(selected, { env: options.env, signal: input.signal });
+      try {
+        if (input.buildMissing)
+          await buildMissing(api, embedder, input);
+        return await api.searchMeetingsCombined(store, embedder, query, {
+          ...input.selection,
+          accountId,
+          ...input.limit === void 0 ? {} : { limit: input.limit },
+          ...input.after === void 0 ? {} : { after: input.after },
+          ...input.maxChunks === void 0 ? {} : { maxChunks: input.maxChunks },
+          ...input.maxRows === void 0 ? {} : { maxRows: input.maxRows },
+          ...input.maxTextBytes === void 0 ? {} : { maxTextBytes: input.maxTextBytes },
+          ...input.signal ? { signal: input.signal } : {}
+        });
+      } finally {
+        await embedder.close();
+      }
+    }, "search"),
+    generate: /* @__PURE__ */ __name(async (input) => {
+      validateMeetingEmbeddings(input);
+      checkCancelled(input.signal);
+      const api = await load();
+      checkCancelled(input.signal);
+      const selected = choice(api, input);
+      const descriptor = api.meetingEmbeddingModel(selected);
+      if (input.yes !== true)
+        return api.proposeMeetingEmbedding(store.meetingVectors, accountId, descriptor, { signal: input.signal });
+      const embedder = await api.openMeetingEmbedder(selected, { env: options.env, signal: input.signal });
+      try {
+        checkCancelled(input.signal);
+        const rebuild = await store.meetingVectors.rebuild({
+          accountId,
+          limit: input.limit,
+          afterTranscriptId: input.afterTranscriptId,
+          maxRows: input.maxRows,
+          maxTextBytes: input.maxTextBytes,
+          signal: input.signal
+        });
+        checkCancelled(input.signal);
+        const result = await api.applyMeetingEmbedding(store.meetingVectors, accountId, embedder, {
+          maxChunks: input.limit,
+          afterHash: input.afterHash,
+          maxRows: input.maxRows,
+          maxTextBytes: input.maxTextBytes,
+          signal: input.signal
+        });
+        return { ...result, applied: true, model: descriptor, rebuild };
+      } finally {
+        await embedder.close();
+      }
+    }, "generate")
+  };
+}, "createMeetingSemanticCapabilities");
+
+// dist/unified-search.js
+var resources = ["messages", "mail", "notes", "meetings"];
+var validateUnifiedSearch = /* @__PURE__ */ __name((input, meetingsOnly = false) => {
+  const limit = input.limit ?? 100;
+  const maxMeetings = input.maxMeetings ?? 100;
+  const only = input.only ?? ["meetings"];
+  if (typeof input.text !== "string" || !input.text.trim() || !Number.isSafeInteger(limit) || limit < 1 || limit > 1e3 || maxMeetings !== "all" && (!Number.isSafeInteger(maxMeetings) || maxMeetings < 1) || input.offset !== void 0 && (!Number.isSafeInteger(input.offset) || input.offset < 0) || !Array.isArray(only) || !only.length || only.some((resource) => !resources.includes(resource)) || meetingsOnly && (only.length !== 1 || only[0] !== "meetings") || input.exact !== void 0 && typeof input.exact !== "boolean")
+    throw new CliError("validation_error", "expected nonempty search text, supported resources, a limit from 1 through 1000 and a whole number of meetings, or all");
+  if (input.meetingCursor !== void 0) {
+    const cursor = input.meetingCursor;
+    if (typeof cursor !== "object" || cursor === null || Array.isArray(cursor) || Object.keys(cursor).some((key) => !["accountId", "query", "meetingOffset", "hitOffset"].includes(key)) || only.length !== 1 || only[0] !== "meetings" || typeof cursor.query !== "string" || !cursor.query.trim() || !Number.isSafeInteger(cursor.accountId) || cursor.accountId < 1 || !Number.isSafeInteger(cursor.meetingOffset) || cursor.meetingOffset < 0 || cursor.meetingOffset > Number.MAX_SAFE_INTEGER - 2 || !Number.isSafeInteger(cursor.hitOffset) || cursor.hitOffset < 0)
+      throw new CliError("validation_error", "meeting continuation requires a source-only cursor bound to its account and query");
+  }
+  return {
+    text: input.text,
+    limit,
+    maxMeetings,
+    only: [...new Set(only)],
+    ...input.offset === void 0 ? {} : { offset: input.offset },
+    exact: input.exact,
+    meetingCursor: input.meetingCursor,
+    signal: input.signal
+  };
+}, "validateUnifiedSearch");
+var runUnifiedSearch = /* @__PURE__ */ __name(async (search, input, meetingsOnly = false) => {
+  const request = validateUnifiedSearch(input, meetingsOnly);
+  checkCancelled(request.signal);
+  const result = await search(request);
+  checkCancelled(request.signal);
+  return result;
+}, "runUnifiedSearch");
+
+// dist/store-connection.js
+var storeUnavailable = /* @__PURE__ */ __name(async () => {
+  throw new CliError("configuration_error", "the shared SQLite meeting store is not available yet");
+}, "storeUnavailable");
+var unavailableStore = {
+  saveMeeting: storeUnavailable,
+  account: storeUnavailable,
+  meetings: storeUnavailable,
+  meeting: storeUnavailable,
+  participants: storeUnavailable,
+  search: storeUnavailable,
+  events: storeUnavailable,
+  queryEvents: storeUnavailable,
+  eventCandidates: storeUnavailable,
+  createEvent: storeUnavailable,
+  createEventSeries: storeUnavailable,
+  setEventSeries: storeUnavailable,
+  linkMeeting: storeUnavailable,
+  cursor: storeUnavailable,
+  setCursor: storeUnavailable
+};
+var connectSelectedProfile = /* @__PURE__ */ __name((connect, profile, intent, context) => {
+  if (!profile)
+    throw new CliError("validation_error", "name a profile: `zm <profile> \u2026`");
+  return connect({ profile, externalId: profileAccountKey(profile), intent, ...context ? { context } : {} });
+}, "connectSelectedProfile");
+var createStoreConnector = /* @__PURE__ */ __name((options = {}) => async (request) => {
+  const { profile, externalId, intent, context } = request ?? {};
+  if (typeof profile !== "string" || !profilePattern.test(profile) || externalId !== profileAccountKey(profile) || intent !== "read" && intent !== "ingestion" && intent !== "preparation" || context !== void 0 && (intent !== "preparation" || typeof context.resolve !== "function" || typeof context.assert !== "function"))
+    throw new CliError("validation_error", "expected a selected Zoom profile and read or ingestion intent");
+  let store;
+  try {
+    const open2 = options.openStore ?? (await import("./store-LODVDPK3.js")).openStore;
+    store = await open2({
+      path: options.path,
+      env: options.env,
+      now: options.now,
+      ...intent === "preparation" ? { readOnly: true } : {}
+    });
+    const connected = store;
+    const meetings = connected.meetings;
+    const key = { provider: "zoom", account: externalId };
+    const accountId = intent === "ingestion" ? await connected.accounts.saveAccount(key, { name: profile }) : (await connected.accounts.storedAccount(key)).id;
+    if (!Number.isSafeInteger(accountId) || accountId < 1)
+      throw new CliError("configuration_error", "the selected meeting account is unavailable");
+    const ownAccount = /* @__PURE__ */ __name((input, what) => {
+      if (input.accountId !== accountId)
+        throw new CliError("validation_error", `${what} account is selected by the connection`);
+      return input;
+    }, "ownAccount");
+    let cachedBatchReader;
+    const batchReader = /* @__PURE__ */ __name(async () => {
+      if (!cachedBatchReader) {
+        const { createMeetingBatchReader } = await import("./services-KC5KQFBS.js");
+        cachedBatchReader = createMeetingBatchReader(connected, accountId);
+      }
+      return cachedBatchReader;
+    }, "batchReader");
+    return {
+      meetingPreparation: {
+        scope: key,
+        create: /* @__PURE__ */ __name(async (upcoming) => {
+          const { createMeetingPreparationService } = await import("./services-KC5KQFBS.js");
+          const reader = connected.contextEvidence;
+          if (context && !reader)
+            throw new CliError("configuration_error", "the installed store does not support bounded communications");
+          const communications = context && reader ? {
+            reader,
+            selections: await context.resolve({
+              storedAccount: connected.accounts.storedAccount.bind(connected.accounts),
+              accountById: connected.meetings.account.bind(connected.meetings)
+            })
+          } : void 0;
+          const service = createMeetingPreparationService(key, accountId, {
+            ...communications ? { communications } : {},
+            meetings,
+            upcoming,
+            projectDiscovery: { vocabulary: connected.knowledge, search: meetings }
+          });
+          return service.prepare.bind(service);
+        }, "create")
+      },
+      store: meetings,
+      accountId,
+      close: /* @__PURE__ */ __name(() => connected.close(), "close"),
+      appendTranscriptsWithReceipt: /* @__PURE__ */ __name((input) => meetings.appendTranscriptsWithReceipt(ownAccount(input, "append")), "appendTranscriptsWithReceipt"),
+      meetingProjectCandidates: /* @__PURE__ */ __name(async (reference, request2) => {
+        const { createStoredMeetingProjectCandidateReader } = await import("./services-KC5KQFBS.js");
+        const read = createStoredMeetingProjectCandidateReader(key, accountId, {
+          meetings,
+          vocabulary: connected.knowledge
+        });
+        return read(reference, request2);
+      }, "meetingProjectCandidates"),
+      meetingProjectEvidence: /* @__PURE__ */ __name(async (project, request2) => {
+        const { readMeetingProjectDiscovery } = await import("./services-KC5KQFBS.js");
+        return readMeetingProjectDiscovery({
+          vocabulary: connected.knowledge,
+          search: { searchHits: /* @__PURE__ */ __name((query, hits) => meetings.searchHits(query, hits), "searchHits") }
+        }, project, { ...request2, accountId });
+      }, "meetingProjectEvidence"),
+      meetingTranscription: createLocalTranscriptionCapabilities({
+        accountId,
+        resolveMeeting: /* @__PURE__ */ __name(async (value, signal) => {
+          const reference = /^[1-9]\d*$/.test(value) ? `meeting:${accountId}/${value}` : value;
+          const target = integrationReference(reference);
+          if (target.parsed.accountId !== accountId)
+            return null;
+          const meeting = await meetings.meetingMetadata({ accountId, meetingId: target.parsed.meetingId, signal });
+          if (meeting.accountId !== accountId || meeting.id !== target.parsed.meetingId || meeting.deletedAt !== null)
+            return null;
+          return { accountId, meetingId: meeting.id, externalId: meeting.externalId };
+        }, "resolveMeeting"),
+        appendTranscriptsWithReceipt: /* @__PURE__ */ __name((input) => meetings.appendTranscriptsWithReceipt(ownAccount(input, "transcription")), "appendTranscriptsWithReceipt")
+      }, { env: options.env, now: options.now }),
+      meetingBatch: {
+        index: /* @__PURE__ */ __name(async (input) => (await batchReader()).index(input), "index"),
+        search: /* @__PURE__ */ __name(async (query, input) => (await batchReader()).search(query, input), "search"),
+        passage: /* @__PURE__ */ __name(async (reference, input) => (await batchReader()).passage(reference, input), "passage")
+      },
+      meetingSearch: /* @__PURE__ */ __name(async (query, request2) => {
+        validateMeetingHitSearch(query, request2);
+        const { searchMeetingHits } = await import("./services-KC5KQFBS.js");
+        return searchMeetingHits({ meetings, knowledge: connected.knowledge }, query, { ...request2, accountId });
+      }, "meetingSearch"),
+      meetingIntegration: {
+        change: /* @__PURE__ */ __name(async (reference, input, mutation = {}) => {
+          const source = integrationReference(reference);
+          if (source.parsed.accountId !== accountId)
+            throw new CliError("not_found", "meeting is unavailable for the selected account");
+          const change = validateMeetingContextChange(input);
+          if (change.action !== "event.link" && change.action !== "person.link")
+            throw new CliError("validation_error", "meeting linking supports only explicit event or person changes");
+          const api = await import("./services-KC5KQFBS.js");
+          await api.resolveMeetingReference(meetings, accountId, source.reference, { signal: mutation.signal });
+          const service = await api.createMeetingContextService({
+            accounts: connected.accounts,
+            meetings,
+            notes: connected.notes,
+            knowledge: connected.knowledge,
+            memories: connected.memories,
+            facts: connected.facts
+          }, key);
+          if (service.accountId !== accountId || service.scope.provider !== key.provider || service.scope.account !== key.account)
+            throw new CliError("invalid_response", "meeting context service returned an inconsistent account");
+          return service.change(source.parsed.meetingId, change, {
+            apply: mutation.apply,
+            dryRun: mutation.dryRun,
+            signal: mutation.signal
+          });
+        }, "change")
+      },
+      unifiedSearch: /* @__PURE__ */ __name(async (input) => {
+        const request2 = validateUnifiedSearch(input);
+        const { searchAllIncludingMeetings } = await import("./services-KC5KQFBS.js");
+        return searchAllIncludingMeetings(connected, key, { ...request2, meetingAccount: key, env: options.env });
+      }, "unifiedSearch"),
+      meetingContext: createMeetingContextCapabilities(connected, meetings, accountId),
+      meetingSemantic: createMeetingSemanticCapabilities(connected, accountId, { env: options.env }),
+      meetingSearches: await (async () => {
+        const { meetingSearchesService } = await import("./services-KC5KQFBS.js");
+        return meetingSearchesService(async () => connected.searches);
+      })(),
+      meetingStats: /* @__PURE__ */ __name(async (request2) => {
+        const { readMeetingStats } = await import("./services-KC5KQFBS.js");
+        return readMeetingStats(connected, { ...request2, accountId });
+      }, "meetingStats"),
+      meetingReview: /* @__PURE__ */ __name(async (request2) => {
+        const { readMeetingReview } = await import("./services-KC5KQFBS.js");
+        return readMeetingReview(connected, { ...request2, accountId });
+      }, "meetingReview"),
+      meetingLinks: /* @__PURE__ */ __name(async (request2) => {
+        const { readMeetingLinks } = await import("./services-KC5KQFBS.js");
+        return readMeetingLinks(connected, { ...request2, accountId });
+      }, "meetingLinks")
+    };
+  } catch (error) {
+    await store?.close().catch(() => void 0);
+    if (isCliError(error) && error.code === "not_found")
+      throw new CliError("configuration_error", "no stored meetings for the selected profile; import transcripts or pull first");
+    if (isCliError(error))
+      throw error;
+    throw new CliError("configuration_error", "could not connect to the shared meeting store; check MESSAGING_STORE and the installed store version");
+  }
+}, "createStoreConnector");
+
+export {
+  duration,
+  bytes,
+  runsLong,
+  commandDeadline,
+  sharedExecution,
+  validateUnifiedSearch,
+  runUnifiedSearch,
+  validateLocalTranscriptionOptions,
+  compactLocalTranscriptionReceipt,
+  validateEvidenceOptions,
+  validatePersonContext,
+  validateTaskKind,
+  validateTaskProposal,
+  integrationReference,
+  addMeetingEmbeddingCommand,
+  meetingSearchDefinition,
+  addMeetingSearchCommands,
+  storeUnavailable,
+  unavailableStore,
+  connectSelectedProfile,
+  createStoreConnector
+};