@wirecat/cli-core 0.398.0 → 0.400.0

package/dist/meetings/read-answers.d.ts

@@ -0,0 +1,167 @@
+import * as v from "valibot";
+import type { MeetingLink } from "./links.js";
+import type { MeetingReviewItem } from "./review.js";
+import type { MeetingSpeakerStats, MeetingStats } from "./stats.js";
+/** One meeting in `review`: what the store holds about it, never transcript text. */
+export declare const meetingReview: v.StrictObjectSchema<{
+    readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly started_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    readonly duration_ms: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly participants_count: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly projects: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    /** Null when the meeting has no current transcript. */
+    readonly transcript: v.NullableSchema<v.StrictObjectSchema<{
+        readonly lines: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly words: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    /** The three who talked longest. */
+    readonly speakers: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly talk_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    /** The newest stored summary; null when there is none. */
+    readonly summary: v.NullableSchema<v.StrictObjectSchema<{
+        readonly source: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly overview: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly next_steps: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const meetingReviewItem: (one: MeetingReviewItem) => v.InferOutput<typeof meetingReview>;
+/** A link shared in meeting chat, with where and how often; `mentions list` answers these. */
+export declare const meetingLink: v.StrictObjectSchema<{
+    readonly url: v.StringSchema<undefined>;
+    readonly domain: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** The Google Docs, Sheets, Slides, Forms or Drive file it names. */
+    readonly document_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly count: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly first_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+    readonly last_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+    readonly senders: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly meetings: v.ArraySchema<v.StrictObjectSchema<{
+        readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const meetingLinkItem: (link: MeetingLink) => v.InferOutput<typeof meetingLink>;
+/** One speaker's talk over the selected meetings; `stats meetings top` answers these. */
+export declare const meetingSpeaker: v.StrictObjectSchema<{
+    /** `person:<id>`, `identity:<id>`, `name:<lowercased name>` or `unknown`. */
+    readonly key: v.StringSchema<undefined>;
+    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly person_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    readonly identity_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lines: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly words: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly talk_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    /** This speaker's part of all talk time, 0–1. */
+    readonly share: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
+}, undefined>;
+export declare const meetingSpeakerItem: (one: MeetingSpeakerStats) => v.InferOutput<typeof meetingSpeaker>;
+/** `stats meetings show`: how much was said over the selected meetings, by week, with the top speakers. */
+export declare const meetingStats: v.StrictObjectSchema<{
+    readonly time_zone: v.StringSchema<undefined>;
+    readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lines: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly words: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly talk_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    /** `week_start` is the Monday, as a date in `time_zone`. */
+    readonly weeks: v.ArraySchema<v.StrictObjectSchema<{
+        readonly week_start: v.StringSchema<undefined>;
+        readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly talk_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    readonly top_speakers: v.ArraySchema<v.StrictObjectSchema<{
+        /** `person:<id>`, `identity:<id>`, `name:<lowercased name>` or `unknown`. */
+        readonly key: v.StringSchema<undefined>;
+        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly person_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly identity_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly lines: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly words: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly talk_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        /** This speaker's part of all talk time, 0–1. */
+        readonly share: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const meetingStatsItem: (found: MeetingStats, top?: number) => v.InferOutput<typeof meetingStats>;
+/** `meetings people`: one page of participant observations whose name or email matches. */
+export declare const meetingParticipants: v.StrictObjectSchema<{
+    readonly schema_version: v.LiteralSchema<1, undefined>;
+    readonly kind: v.LiteralSchema<"meeting_participants", undefined>;
+    readonly account_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly query: v.StringSchema<undefined>;
+    readonly items: v.ArraySchema<v.StrictObjectSchema<{
+        readonly participant_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly meeting_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly identity_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly display_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly email: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /** Several identities on one page are observations, never speaker attribution or person links. */
+    readonly ambiguity: v.StrictObjectSchema<{
+        readonly scope: v.LiteralSchema<"page", undefined>;
+        readonly multiple_identities: v.BooleanSchema<undefined>;
+        readonly identity_ids: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    }, undefined>;
+    readonly coverage: v.StrictObjectSchema<{
+        readonly scanned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly read_bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly archive_completeness: v.LiteralSchema<"unknown", undefined>;
+        readonly truncated_by: v.NullableSchema<v.PicklistSchema<("limit" | "read_bytes" | "scan_limit")[], undefined>, undefined>;
+    }, undefined>;
+    readonly page: v.StrictObjectSchema<{
+        readonly mode: v.LiteralSchema<"cursor", undefined>;
+        readonly limit: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly has_more: v.BooleanSchema<undefined>;
+        readonly next_cursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+/** `meetings passage`: a transcript line with the lines around it. */
+export declare const meetingPassage: v.StrictObjectSchema<{
+    readonly schema_version: v.LiteralSchema<1, undefined>;
+    readonly kind: v.LiteralSchema<"meeting_context", undefined>;
+    readonly source: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly target_ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly target_fingerprint: v.StringSchema<undefined>;
+    readonly fingerprint: v.StringSchema<undefined>;
+    readonly revision: v.PicklistSchema<["current", "superseded"], undefined>;
+    readonly limits: v.StrictObjectSchema<{
+        readonly before: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly after: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly max_read_bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly content_bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly coverage: v.StrictObjectSchema<{
+        readonly included: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly before: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly after: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly has_before: v.BooleanSchema<undefined>;
+        readonly has_after: v.BooleanSchema<undefined>;
+        readonly truncated_by: v.NullableSchema<v.PicklistSchema<"bytes"[], undefined>, undefined>;
+        readonly before_ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly after_ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly continuation: v.LiteralSchema<"anchor-inclusive", undefined>;
+        readonly archive_completeness: v.LiteralSchema<"unknown", undefined>;
+        readonly input: v.LiteralSchema<"bounded-meeting-context", undefined>;
+    }, undefined>;
+    readonly items: v.ArraySchema<v.StrictObjectSchema<{
+        readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly fingerprint: v.StringSchema<undefined>;
+        readonly transcript_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly content_hash: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly start_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly end_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly speaker_participant_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly speaker_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly text: v.StringSchema<undefined>;
+        readonly revision: v.PicklistSchema<["current", "superseded"], undefined>;
+    }, undefined>, undefined>;
+}, undefined>;

package/dist/meetings/read-answers.js

@@ -0,0 +1,183 @@
+import { isoTime, reference } from "@wirecat/cli-base/standards";
+import * as v from "valibot";
+import { formatMeetingReference } from "./reference.js";
+const text = v.string();
+const count = v.pipe(v.number(), v.integer(), v.minValue(0));
+const id = v.pipe(v.number(), v.integer(), v.minValue(1));
+const iso = (ms) => (ms === null ? null : new Date(ms).toISOString());
+const meetingRef = (accountId, meetingId) => formatMeetingReference({ type: "meeting", accountId, meetingId });
+/** One meeting in `review`: what the store holds about it, never transcript text. */
+export const meetingReview = v.strictObject({
+    ref: reference,
+    id: v.pipe(v.string(), v.minLength(1)),
+    title: v.nullable(text),
+    started_at: v.nullable(isoTime),
+    duration_ms: v.nullable(count),
+    participants_count: v.nullable(count),
+    projects: v.array(text),
+    /** Null when the meeting has no current transcript. */
+    transcript: v.nullable(v.strictObject({ lines: count, words: count })),
+    /** The three who talked longest. */
+    speakers: v.array(v.strictObject({ name: v.nullable(text), talk_ms: count })),
+    /** The newest stored summary; null when there is none. */
+    summary: v.nullable(v.strictObject({
+        source: text,
+        title: v.nullable(text),
+        overview: v.nullable(text),
+        next_steps: v.array(text),
+        url: v.nullable(text),
+    })),
+});
+export const meetingReviewItem = (one) => ({
+    ref: meetingRef(one.accountId, one.meetingId),
+    id: String(one.meetingId),
+    title: one.title,
+    started_at: iso(one.startedAt),
+    duration_ms: one.durationMs,
+    participants_count: one.participantsCount,
+    projects: one.projects,
+    transcript: one.transcript,
+    speakers: one.speakers.map((speaker) => ({ name: speaker.name, talk_ms: speaker.talkMs })),
+    summary: one.summary && {
+        source: one.summary.source,
+        title: one.summary.title,
+        overview: one.summary.overview,
+        next_steps: one.summary.nextSteps,
+        url: one.summary.url,
+    },
+});
+/** A link shared in meeting chat, with where and how often; `mentions list` answers these. */
+export const meetingLink = v.strictObject({
+    url: text,
+    domain: v.nullable(text),
+    /** The Google Docs, Sheets, Slides, Forms or Drive file it names. */
+    document_id: v.nullable(text),
+    count,
+    first_at: isoTime,
+    last_at: isoTime,
+    senders: v.array(text),
+    meetings: v.array(v.strictObject({ ref: reference, title: v.nullable(text) })),
+});
+export const meetingLinkItem = (link) => ({
+    url: link.url,
+    domain: link.domain,
+    document_id: link.documentId,
+    count: link.count,
+    first_at: new Date(link.firstAt).toISOString(),
+    last_at: new Date(link.lastAt).toISOString(),
+    senders: link.senders,
+    meetings: link.meetings.map((one) => ({ ref: meetingRef(one.accountId, one.meetingId), title: one.title })),
+});
+/** One speaker's talk over the selected meetings; `stats meetings top` answers these. */
+export const meetingSpeaker = v.strictObject({
+    /** `person:<id>`, `identity:<id>`, `name:<lowercased name>` or `unknown`. */
+    key: text,
+    name: v.nullable(text),
+    person_id: v.nullable(id),
+    identity_id: v.nullable(id),
+    meetings: count,
+    lines: count,
+    words: count,
+    talk_ms: count,
+    /** This speaker's part of all talk time, 0–1. */
+    share: v.pipe(v.number(), v.minValue(0), v.maxValue(1)),
+});
+export const meetingSpeakerItem = (one) => ({
+    key: one.key,
+    name: one.name,
+    person_id: one.personId,
+    identity_id: one.identityId,
+    meetings: one.meetings,
+    lines: one.lines,
+    words: one.words,
+    talk_ms: one.talkMs,
+    share: one.share,
+});
+/** `stats meetings show`: how much was said over the selected meetings, by week, with the top speakers. */
+export const meetingStats = v.strictObject({
+    time_zone: text,
+    meetings: count,
+    lines: count,
+    words: count,
+    talk_ms: count,
+    /** `week_start` is the Monday, as a date in `time_zone`. */
+    weeks: v.array(v.strictObject({ week_start: text, meetings: count, talk_ms: count })),
+    top_speakers: v.array(meetingSpeaker),
+});
+export const meetingStatsItem = (found, top = 10) => ({
+    time_zone: found.timeZone,
+    meetings: found.meetings,
+    lines: found.lines,
+    words: found.words,
+    talk_ms: found.talkMs,
+    weeks: found.weeks.map((week) => ({ week_start: week.weekStart, meetings: week.meetings, talk_ms: week.talkMs })),
+    top_speakers: found.speakers.slice(0, top).map(meetingSpeakerItem),
+});
+const truncated = (...why) => v.nullable(v.picklist(why));
+/** `meetings people`: one page of participant observations whose name or email matches. */
+export const meetingParticipants = v.strictObject({
+    schema_version: v.literal(1),
+    kind: v.literal("meeting_participants"),
+    account_id: id,
+    query: text,
+    items: v.array(v.strictObject({
+        participant_id: id,
+        meeting_id: id,
+        identity_id: id,
+        display_name: v.nullable(text),
+        email: v.nullable(text),
+    })),
+    /** Several identities on one page are observations, never speaker attribution or person links. */
+    ambiguity: v.strictObject({ scope: v.literal("page"), multiple_identities: v.boolean(), identity_ids: v.array(id) }),
+    coverage: v.strictObject({
+        scanned: count,
+        read_bytes: count,
+        archive_completeness: v.literal("unknown"),
+        truncated_by: truncated("limit", "scan_limit", "read_bytes"),
+    }),
+    page: v.strictObject({
+        mode: v.literal("cursor"),
+        limit: count,
+        has_more: v.boolean(),
+        next_cursor: v.optional(text),
+    }),
+});
+const revision = v.picklist(["current", "superseded"]);
+/** `meetings passage`: a transcript line with the lines around it. */
+export const meetingPassage = v.strictObject({
+    schema_version: v.literal(1),
+    kind: v.literal("meeting_context"),
+    source: reference,
+    target_ref: reference,
+    target_fingerprint: text,
+    fingerprint: text,
+    revision,
+    limits: v.strictObject({ before: count, after: count, bytes: count, max_read_bytes: count }),
+    content_bytes: count,
+    coverage: v.strictObject({
+        included: count,
+        before: count,
+        after: count,
+        has_before: v.boolean(),
+        has_after: v.boolean(),
+        truncated_by: truncated("bytes"),
+        before_ref: v.nullable(reference),
+        after_ref: v.nullable(reference),
+        continuation: v.literal("anchor-inclusive"),
+        archive_completeness: v.literal("unknown"),
+        input: v.literal("bounded-meeting-context"),
+    }),
+    items: v.array(v.strictObject({
+        ref: reference,
+        fingerprint: text,
+        transcript_id: id,
+        content_hash: v.nullable(text),
+        position: count,
+        start_ms: count,
+        end_ms: count,
+        speaker_participant_id: v.nullable(id),
+        speaker_name: v.nullable(text),
+        text,
+        revision,
+    })),
+});

package/dist/runs/run.d.ts

@@ -87,7 +87,7 @@ export declare const runsDirFor: (app: AppIdentity, env?: NodeJS.ProcessEnv) =>
  * `run.json` is written **now**, with `status: "running"`, and again by `finish`. A directory
  * holding events and no metadata is a special case `runs list` would carry forever.
  *
- * Each write also appends the metadata to the day's `index.jsonl`, which `runs list` and `runs search`
+ * Each write also appends the metadata to the day's `index.jsonl`, which `runs list` and `search runs`
  * read instead of every `run.json`. It is only a cache: pruned with its day, and a day without one is read
  * the slow way.
  */
@@ -95,13 +95,21 @@ export declare const startRun: (options: StartRunOptions) => Run;
 export declare const runtime: () => string;
 /** `20260920T084431Z-chats-list-a81f2c` — sortable, and readable without opening it. */
 export declare const newRunId: (startedAt: Date, command: string) => string;
+export interface RunListFilter {
+    runId?: string;
+    command?: string;
+    profile?: string;
+    status?: RunMetadata["status"];
+    errorCode?: string;
+}
 /**
  * Newest first, which is the order anyone asking "what did I just do" wants. Days before `since` are
  * not opened, nor any day once `atLeast` runs are in hand.
  */
-export declare const listRuns: (runsDir: string, { since, atLeast }?: {
+export declare const listRuns: (runsDir: string, { since, atLeast, filter, }?: {
     since?: number;
     atLeast?: number;
+    filter?: RunListFilter;
 }) => RunMetadata[];
 export declare const findRun: (runsDir: string, id: string) => {
     dir: string;

package/dist/runs/run.js

@@ -19,7 +19,7 @@ export const runsDirFor = (app, env = process.env) => join(resolvePaths({ appNam
  * `run.json` is written **now**, with `status: "running"`, and again by `finish`. A directory
  * holding events and no metadata is a special case `runs list` would carry forever.
  *
- * Each write also appends the metadata to the day's `index.jsonl`, which `runs list` and `runs search`
+ * Each write also appends the metadata to the day's `index.jsonl`, which `runs list` and `search runs`
  * read instead of every `run.json`. It is only a cache: pruned with its day, and a day without one is read
  * the slow way.
  */
@@ -124,17 +124,25 @@ const writeRunFile = (dir, metadata) => {
         // The index only makes reading faster; a day without one is read run by run.
     }
 };
+const matchesListFilter = (run, filter) => (filter.runId === undefined || run.runId === filter.runId) &&
+    (filter.command === undefined || run.command === filter.command) &&
+    (filter.profile === undefined || run.profile === filter.profile) &&
+    (filter.status === undefined || run.status === filter.status) &&
+    (filter.errorCode === undefined || run.errorCode === filter.errorCode);
 /**
  * Newest first, which is the order anyone asking "what did I just do" wants. Days before `since` are
  * not opened, nor any day once `atLeast` runs are in hand.
  */
-export const listRuns = (runsDir, { since, atLeast = Number.POSITIVE_INFINITY } = {}) => {
+export const listRuns = (runsDir, { since, atLeast = Number.POSITIVE_INFINITY, filter = {}, } = {}) => {
     const first = since === undefined ? undefined : day(new Date(since));
     const runs = [];
     for (const date of days(runsDir).sort().reverse()) {
         if ((first !== undefined && date < first) || runs.length >= atLeast)
             break;
-        runs.push(...runsOfDay(join(runsDir, date)));
+        for (const metadata of runsOfDay(join(runsDir, date))) {
+            if (matchesListFilter(metadata, filter))
+                runs.push(metadata);
+        }
     }
     return runs;
 };

package/dist/sends/journal.d.ts

@@ -59,6 +59,13 @@ export interface SendEntry {
     reservation?: string;
     errorCode?: string;
 }
+export interface SendFilter {
+    outcome?: SendOutcome;
+    chatId?: Id;
+    operationId?: string;
+    errorCode?: string;
+    key?: string;
+}
 /**
  * `<state dir>/sends/<profile>.jsonl` — beside `runs`, never in the cache directory, so that
  * clearing a cache cannot erase what was sent in the owner's name.
@@ -88,5 +95,5 @@ export declare class SendJournal {
      * Oldest first, each reservation folded into its outcome; one with no outcome yet is in flight,
      * or its process died. A line that does not parse is skipped: a torn last write must not block sending.
      */
-    entries(): SendEntry[];
+    entries(filter?: SendFilter): SendEntry[];
 }

package/dist/sends/journal.js

@@ -54,13 +54,20 @@ export class SendJournal {
      * Oldest first, each reservation folded into its outcome; one with no outcome yet is in flight,
      * or its process died. A line that does not parse is skipped: a torn last write must not block sending.
      */
-    entries() {
+    entries(filter) {
         const lines = this.#lines();
         const settled = new Set(lines.filter((entry) => entry.outcome !== "reserved").map((entry) => entry.reservation));
-        return lines
+        const entries = lines
             .filter((entry) => entry.outcome !== "reserved" || !settled.has(entry.reservation))
             .map(({ reservation, ...entry }) => (entry.outcome === "reserved" ? { ...entry, reservation } : entry))
             .map(withSendId);
+        return filter === undefined
+            ? entries
+            : entries.filter((entry) => (filter.outcome === undefined || entry.outcome === filter.outcome) &&
+                (filter.chatId === undefined || entry.chatId === filter.chatId) &&
+                (filter.operationId === undefined || entry.operationId === filter.operationId) &&
+                (filter.errorCode === undefined || entry.errorCode === filter.errorCode) &&
+                (filter.key === undefined || entry.key === filter.key));
     }
     #lines() {
         let text;

package/dist/sends/permissions.d.ts

@@ -17,8 +17,12 @@ export type PermissionKey = string;
 export declare const skipFlagFor: (key: string) => "--allow-dangerous" | "--yes";
 /** Only what cannot be undone asks; the tool is meant to work without questions (owner, NEED-460). */
 export declare const DEFAULT_PERMISSIONS: Readonly<Record<PermissionKey, Level>>;
+/** Lets an MCP server offer the commands that change what a later run may do (`grantsAuthority`). */
+export declare const AUTHORITY_KEY: PermissionKey;
+/** Whether these levels let an agent run a command that changes what a later run may do; `ask` does, as for any write. */
+export declare const authorityAllowed: (levels: Readonly<Record<PermissionKey, Level>>) => boolean;
 /** The resources at the top of the command tree, which `readOnly` and `allow` turn read-only as a whole. */
-export declare const RESOURCES: readonly ["messages", "reactions", "polls", "topics", "chats", "contacts", "account", "bot", "conversations", "tags", "mentions", "search", "searches", "tasks", "replies", "attachments", "stats", "store", "metadata"];
+export declare const RESOURCES: readonly ["messages", "reactions", "polls", "topics", "chats", "contacts", "account", "bot", "conversations", "tags", "mentions", "search", "searches", "tasks", "replies", "attachments", "stats", "store", "metadata", "mcp"];
 /** The command path an old `allow` word stood for, as one key — what an MCP tool's `permission` is checked against. */
 export declare const keyOfWord: (word: Permission) => PermissionKey;
 /**

package/dist/sends/permissions.js

@@ -77,6 +77,15 @@ export const DEFAULT_PERMISSIONS = {
     "chats.clear": "ask",
     // NEED-568: a rule writes to people with nobody typing a command; it waits for the owner's own allow.
     "replies.send": "deny",
+    // NEED-1662: an agent that changes settings, schedules or recipients could lift its own limits; the owner opts in.
+    "mcp.authority": "deny",
+};
+/** Lets an MCP server offer the commands that change what a later run may do (`grantsAuthority`). */
+export const AUTHORITY_KEY = "mcp.authority";
+/** Whether these levels let an agent run a command that changes what a later run may do; `ask` does, as for any write. */
+export const authorityAllowed = (levels) => {
+    const { level } = levelFor(levels, AUTHORITY_KEY);
+    return level === "allow" || level === "ask";
 };
 /** The resources at the top of the command tree, which `readOnly` and `allow` turn read-only as a whole. */
 export const RESOURCES = [
@@ -99,6 +108,7 @@ export const RESOURCES = [
     "stats",
     "store",
     "metadata",
+    "mcp",
 ];
 const OLD_WORDS = {
     send: ["messages.send", "polls.create", "chats.start"],
@@ -428,7 +438,7 @@ export const keyForCommand = (path) => {
         const inner = keyForCommand(path.slice(1));
         return `bot.${inner ?? path.slice(1).join(".")}`;
     }
-    if (top === undefined || HOUSEKEEPING.has(top))
+    if (top === undefined || HOUSEKEEPING.has(top) || (top === "search" && next === "runs"))
         return null;
     // Picture models moved from `models image` (0.270.0); a model is housekeeping wherever it is listed.
     if (top === "images" && next === "models")

package/dist/sends/recipients.d.ts

@@ -7,6 +7,10 @@ export interface Recipient {
     partnerId?: Id;
     addedAt: string;
 }
+export interface RecipientFilter {
+    id?: Id;
+    title?: string;
+}
 /**
  * A state file, not a setting: the configuration schema has deliberately no place for a chat id,
  * and this list is data about a profile rather than a preference.
@@ -25,6 +29,10 @@ export declare class RecipientList {
     constructor(path: string, command: string, lockWaitMs?: number | undefined);
     /** `undefined` when the list is off. A file that cannot be read refuses rather than opening up. */
     read(): Recipient[] | undefined;
+    list(filter?: RecipientFilter): {
+        state: "off" | "empty" | "on";
+        items: Recipient[];
+    };
     /** Whether it was new. Adding one again fills in a partner an older entry was stored without. */
     add(recipient: Recipient): boolean;
     /** `add` waiting for the lock on timers: `recipients add` connects, so it runs inside `serve` when one holds the account. */

package/dist/sends/recipients.js

@@ -36,6 +36,15 @@ export class RecipientList {
                 `fix the file or turn the list off with \`${this.command} recipients clear\``);
         }
     }
+    list(filter = {}) {
+        const chats = this.read();
+        // A query that matches nothing must not describe a nonempty allowlist as allowing nowhere.
+        return {
+            state: chats === undefined ? "off" : chats.length === 0 ? "empty" : "on",
+            items: (chats ?? []).filter((chat) => (filter.id === undefined || chat.id === filter.id) &&
+                (filter.title === undefined || chat.title?.toLocaleLowerCase() === filter.title.toLocaleLowerCase())),
+        };
+    }
     /** Whether it was new. Adding one again fills in a partner an older entry was stored without. */
     add(recipient) {
         return this.#locked(() => this.#added(recipient));

package/dist/services/admin-statistics.js

@@ -216,12 +216,12 @@ export const adminStatisticsService = (deps) => ({
             cutoff,
             olderThan: query.olderThan === undefined && pinned
                 ? pinned.options.olderThan
-                : duration(query.olderThan ?? "24h", "--older-than"),
+                : duration(query.olderThan ?? "24h", "older_than"),
             within: query.within === undefined && pinned ? pinned.options.within : duration(query.within ?? "7d", "--within"),
             joinSince: window.since ?? pinned?.options.joinSince ?? cutoff - 30 * 86_400_000,
             joinUntil: window.until ?? pinned?.options.joinUntil ?? cutoff,
-            minViews: count(query.minViews ?? pinned?.options.minViews ?? 1, "--min-views"),
-            maxReplies: count(query.maxReplies ?? pinned?.options.maxReplies ?? 0, "--max-replies"),
+            minViews: count(query.minViews ?? pinned?.options.minViews ?? 1, "min_views"),
+            maxReplies: count(query.maxReplies ?? pinned?.options.maxReplies ?? 0, "max_replies"),
             answerers: query.answerers === undefined && pinned
                 ? pinned.options.answerers
                 : await answerers(store, query.answerers ?? [], prepared.execution.accounts),

package/dist/services/chat-documents.d.ts

@@ -23,6 +23,7 @@ export interface ChatDocumentsService {
     list(chat: string, window: {
         limit?: number;
         offset: number;
+        ref?: string;
     }): Promise<ChatDocuments>;
 }
 export declare const chatDocumentsService: (deps: ServiceDeps) => ChatDocumentsService;

package/dist/services/chat-documents.js

@@ -1,12 +1,18 @@
 import { googleDocumentLinks } from "../domain/google-documents.js";
-import { formatLocator } from "../domain/locator.js";
+import { formatLocator, parseLocator } from "../domain/locator.js";
 import { accountStore } from "./deps.js";
 import { chatIdIn } from "./message-resolution.js";
 export const chatDocumentsService = (deps) => ({
-    list: async (chat, { limit, offset }) => {
+    list: async (chat, { limit, offset, ref }) => {
         const store = await accountStore(deps);
         const chatId = await chatIdIn(deps.messenger, chat, store, { includeLeft: true });
-        const items = (await store.messages.documentLinkMessages(chatId)).flatMap((message) => googleDocumentLinks(message.text).map(({ url, documentId }) => {
+        const target = ref === undefined ? undefined : parseLocator(ref);
+        const sameScope = target === undefined ||
+            (target.provider === store.account.provider && target.account === store.account.account && target.chat === chatId);
+        const messages = sameScope
+            ? await store.messages.documentLinkMessages(chatId, target ? { messageId: target.message } : {})
+            : [];
+        const items = messages.flatMap((message) => googleDocumentLinks(message.text).map(({ url, documentId }) => {
             const stored = documentId === null ? undefined : message.documents.find((one) => one.fileId === documentId);
             return {
                 url,

package/dist/services/chats.d.ts

@@ -79,7 +79,7 @@ export interface ChatsService {
         track?: boolean;
     }): Promise<FetchedMembers>;
     /** The chats whose members `serve` fetches daily, from the store. */
-    tracked(): Promise<TrackedChat[]>;
+    tracked(query?: QueryAst): Promise<TrackedChat[]>;
     /** One chat's tracking and its member counts of the last `TRACKED_DAYS` days, tracked or not. */
     trackedChat(chat: string): Promise<{
         chatId: Id;

package/dist/services/chats.js

@@ -7,7 +7,7 @@ import { syncsOneChat } from "../ports/traits.js";
 import { typedCommand } from "../runs/scope.js";
 import { codeOf, guardedWrite } from "../sends/guarded.js";
 import { newOperationId } from "../sends/send-id.js";
-import { CHAT_COLUMNS, queryFilter, } from "../store/store.js";
+import { CHAT_COLUMNS, queryFilter, TRACKED_CHAT_COLUMNS, } from "../store/store.js";
 import { chatStats } from "./chat-stats.js";
 import { accountStore, accountStoreIfOpen, fromStore, nothingStored, unlessBusy } from "./deps.js";
 import { memberEvents } from "./member-history.js";
@@ -210,7 +210,10 @@ export const chatsService = (deps) => ({
         const tracked = (await store.roster.trackedChats()).some((one) => one.chatId === chatId);
         return { chatId, read: members.length, participants, complete, more, ...change, tracked };
     },
-    tracked: async () => (await accountStore(deps)).roster.trackedChats(),
+    tracked: async (query) => {
+        const where = query ? queryFilter(query, TRACKED_CHAT_COLUMNS, { command: "chats tracking list" }) : undefined;
+        return (await accountStore(deps)).roster.trackedChats(where ? { where } : {});
+    },
     memberHistory: async (chat, { since }) => {
         const store = await accountStore(deps);
         const chatId = await chatIdIn(deps.messenger, chat, store, { includeLeft: true });