@wirecat/cli-core 0.389.0 → 0.391.0

package/CHANGELOG.md

@@ -5,6 +5,38 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
+## Unreleased
+
+## 0.391.0 — 23.10.2026
+
+### Changed — may break callers
+
+- Reads never mark chats read: `messages list`, `inbox` and `review` no longer take `--mark-read` or
+  `--no-mark-read`. Remove `catch_up_marks_read` from configuration; it is now refused. Use
+  `<cli> <profile> chats mark-read <chat>` when you intend to send a read receipt.
+- `tags auto` declares its messenger read, including the preparatory read requested with `--sync-first`.
+
+### Added
+
+- `readMeetingReview` (`@wirecat/cli-core/services`) and `MeetingStore.meetingReview`: the newest meetings of a
+  selection, each with its newest summary (overview, next steps), transcript lines and words, the three who talked
+  longest and its confirmed projects. No transcript text is read out.
+- `readMeetingLinks` (`@wirecat/cli-core/services`) and `MeetingStore.meetingChatLines`: links shared in the chat of
+  the selected meetings, most shared first, with who shared them, in which meetings, and the Google file each names.
+  Found when read, not stored; at most 100000 chat messages, more is an error.
+- A local read with an unknown profile now lists the profiles on this computer in its error and
+  `details.profiles`, so a typo does not suggest linking a new account. A configured profile with no
+  saved account still explains how to fill its local history.
+
+- Unknown permission keys now refuse messenger commands with `configuration_error`, including typos after
+  the resource name such as `messages.sedn`. Correct the key or remove it with `config unset`; a warning
+  no longer leaves the intended restriction unenforced.
+- **Message search reads `"a b"~N`: the words at most N words apart in one message, in any order.** It was a
+  `query.unsupported-operator` error; now it is syntax for `text:`, `exact:`, `transcript:`, `content:` and a bare
+  word, N up to 50 (`query.invalid-number` above). Words match in any form, as in a phrase; `exact:` keeps the typed
+  forms. Unlike Lucene, order costs nothing: `"a b"~0` finds "b a" too. `word~1` stays an error. A saved search may
+  now hold `~N`. `QUERY_OPERATORS` splits the `fuzzy / proximity` row into `proximity` and `fuzzy`.
+
 ## 0.389.0 — 22.10.2026
 
 ### Added
@@ -15,6 +47,11 @@ shape of this file.
   so a local transcript beside the provider's does not count twice. `meetings.meetingStats` on the store and
   `aggregateMeetingStats` for rows a host already has.
 
+### Fixed
+
+- **A recorded one-shot command's `meta.run_id` names the run it kept**, so `runs show <run_id>` finds it. It named
+  the process's own run, which is never kept.
+
 ## 0.388.0 — 22.10.2026
 
 ### Added

package/dist/cli/context.js

@@ -79,6 +79,7 @@ export const baseContext = (command, resolveSettings) => {
                 keepFailed: settings.keepFailedRuns,
                 trace: settings.trace,
                 keepDays: settings.keepRunsForDays,
+                processRun: !environment.agent,
                 format,
                 streams,
                 env,

package/dist/cli/effects.d.ts

@@ -36,6 +36,8 @@ export declare const isLogin: (command: Command) => boolean;
  * (merge/unmerge, claim/release) or keeps the old value in the task's history; under the lock a close only suggests.
  */
 export declare const destroysNothing: <T extends Command>(command: T) => T;
+/** A local edit remains an edit even when it first fetches metadata from the messenger. */
+export declare const changesStore: <T extends Command>(command: T) => T;
 /**
  * Whether `<PREFIX>_READ_ONLY` refuses the command as a change to the store. Every write that stays on this machine
  * is refused unless `destroysNothing` marks it, so a new one fails closed (WC-PERM-12). A fetch (`remote: "read"`)

package/dist/cli/effects.js

@@ -52,6 +52,12 @@ export const destroysNothing = (command) => {
     KEPT_UNDER_LOCK.add(command);
     return command;
 };
+const STORE_WRITES = new WeakSet();
+/** A local edit remains an edit even when it first fetches metadata from the messenger. */
+export const changesStore = (command) => {
+    STORE_WRITES.add(command);
+    return command;
+};
 /**
  * Whether `<PREFIX>_READ_ONLY` refuses the command as a change to the store. Every write that stays on this machine
  * is refused unless `destroysNothing` marks it, so a new one fails closed (WC-PERM-12). A fetch (`remote: "read"`)
@@ -59,8 +65,8 @@ export const destroysNothing = (command) => {
  */
 export const isStoreChange = (command) => {
     const effects = metaOf(command).effects;
-    return (effects?.remote === "none" &&
-        effects.local === "write" &&
+    return ((effects?.remote === "none" || STORE_WRITES.has(command)) &&
+        effects?.local === "write" &&
         !KEPT_UNDER_LOCK.has(command) &&
         !changesAuthority(command));
 };

package/dist/cli/messenger/catch-up.d.ts

@@ -1,22 +1,3 @@
 import type { Command } from "commander";
-import type { Id, Message } from "../../domain/models.js";
-import type { MarkedRead } from "../../services/chats.js";
-import type { Services } from "../../services/index.js";
-import type { Settings } from "../settings.js";
-export declare const MARK_READ_OPTION: readonly ["--mark-read", "also mark each chat shown read, up to the newest message shown; the other side sees it"];
-export declare const NO_MARK_READ_OPTION: readonly ["--no-mark-read", "do not, whatever the catch_up_marks_read setting says"];
-/**
- * The typed flag decides; without one, the owner's `catch_up_marks_read` setting, off unless turned on (NEED-566).
- * An agent's run never marks read on that setting: the other side sees it, so only an agent that asks does.
- */
-export declare const marksRead: (typed: boolean | undefined, settings: Settings, command: Command) => boolean;
 /** Whose `--new` points a run moves: an agent's are its own, so the owner's `inbox --new` still shows everything. */
 export declare const pointsOf: <N extends "inbox" | "review">(command: Command, name: N) => N | `mcp-${N}`;
-/**
- * Marks each chat read up to the newest message shown in it — never further, so what arrived after
- * the read stays unread. Through the send guard, so `permissions.chats.mark-read` applies.
- */
-export declare const markShown: (services: Services, chats: {
-    id: Id;
-    messages: Pick<Message, "id" | "timestamp">[];
-}[], warn: (message: string) => void) => Promise<MarkedRead[]>;

package/dist/cli/messenger/catch-up.js

@@ -1,46 +1,3 @@
-import { CliError, isCliError } from "@wirecat/cli-base";
 import { environmentOf } from "../context.js";
-export const MARK_READ_OPTION = [
-    "--mark-read",
-    "also mark each chat shown read, up to the newest message shown; the other side sees it",
-];
-export const NO_MARK_READ_OPTION = ["--no-mark-read", "do not, whatever the catch_up_marks_read setting says"];
-// Neither is offered to an agent (`ownerOnlyOption`): a read tool may run unasked, and the other side sees a mark.
-// An agent marks read with `chats mark-read`, a write.
-/**
- * The typed flag decides; without one, the owner's `catch_up_marks_read` setting, off unless turned on (NEED-566).
- * An agent's run never marks read on that setting: the other side sees it, so only an agent that asks does.
- */
-export const marksRead = (typed, settings, command) => {
-    const marking = typed ?? (environmentOf(command).agent ? false : settings.catchUpMarksRead);
-    if (marking && settings.offline) {
-        throw new CliError("validation_error", "--mark-read tells the messenger; not with --offline");
-    }
-    return marking;
-};
 /** Whose `--new` points a run moves: an agent's are its own, so the owner's `inbox --new` still shows everything. */
 export const pointsOf = (command, name) => environmentOf(command).agent ? `mcp-${name}` : name;
-/**
- * Marks each chat read up to the newest message shown in it — never further, so what arrived after
- * the read stays unread. Through the send guard, so `permissions.chats.mark-read` applies.
- */
-export const markShown = async (services, chats, warn) => {
-    const marked = [];
-    for (const { id, messages } of chats) {
-        const newest = messages.reduce((last, one) => (last === undefined || Date.parse(one.timestamp) >= Date.parse(last.timestamp) ? one : last), undefined);
-        if (newest === undefined)
-            continue;
-        try {
-            const { chatId, until } = await services.chats.markRead({ chat: id, until: newest.id });
-            marked.push({ chatId, until });
-        }
-        catch (error) {
-            // A hold refuses every chat alike; what was read is still the answer, as reads go on during one.
-            if (!isCliError(error) || error.details.sendBlock === undefined)
-                throw error;
-            warn(`${error.message}; nothing more was marked read`);
-            break;
-        }
-    }
-    return marked;
-};

package/dist/cli/messenger/context.js

@@ -282,7 +282,10 @@ export const connectedFor = async (command, messenger, base, options) => {
         }),
     };
 };
-const unrecorded = (command, messenger, profile, offline) => {
+const unrecorded = (command, messenger, profile, { offline, profilesHere }) => {
+    if (!profilesHere.includes(profile)) {
+        return new CliError("not_found", `no profile named "${profile}" — profiles here: ${profilesHere.length > 0 ? profilesHere.join(", ") : "none"}`, { profiles: profilesHere });
+    }
     const words = `${messenger.app.command} ${asFirstWord(profile)}`;
     const setup = rootOf(command).commands.some((one) => one.name() === "setup") ? `\`${words}setup\`` : undefined;
     if (messenger.history === "store")
@@ -346,14 +349,14 @@ export const messengerContext = (command, messenger, resolving = {}) => {
     refuseDenied(command, base.settings);
     refuseLacking(messenger, pathOf(command));
     for (const key of unknownPermissionKeys(base.settings.permissions, knownPermissionKeys(command, messenger.permissionKey))) {
-        base.renderer.warn(`permissions.${key} names no command and does nothing — \`config unset permissions.${key}\``);
+        throw new CliError("configuration_error", `permissions.${key} names no command — remove it with \`${app.command} ${asFirstWord(profile)}config unset permissions.${key}\``, { permission: key });
     }
     // Read when warning, not now: serve swaps the renderer's methods for log records after this.
     const warn = (text, warning) => base.renderer.warn(text, warning);
     const accountFor = () => {
         const account = messenger.accountOf?.(command) ?? recalledAccount(app, provider, profile, base.env);
         if (!account)
-            throw unrecorded(command, messenger, profile, base.settings.offline);
+            throw unrecorded(command, messenger, profile, base.settings);
         return account;
     };
     const guard = messenger.guard?.(command, base.settings, warn) ??

package/dist/cli/messenger/inbox.js

@@ -5,11 +5,11 @@ import { renderMessages } from "../../render/messages.js";
 import { CHAT_KINDS } from "../../services/chats.js";
 import { kindsOf } from "../../services/inbox.js";
 import { modelWith } from "../../speech/hearing.js";
-import { ownerOnlyOption, REMOTE_READ } from "../effects.js";
+import { REMOTE_READ } from "../effects.js";
 import { renderAnswer } from "../envelope.js";
 import { queryHelp } from "../list-query.js";
 import { positiveCount } from "../paging.js";
-import { MARK_READ_OPTION, markShown, marksRead, NO_MARK_READ_OPTION, pointsOf } from "./catch-up.js";
+import { pointsOf } from "./catch-up.js";
 import { catchUpQuery, INBOX_QUERY, inboxAnswer } from "./catch-up-answers.js";
 import { messengerContext } from "./context.js";
 import { hearForCommand, MODEL_OPTION, spokenItems, TRANSCRIBE_OPTION } from "./hearing-command.js";
@@ -42,10 +42,9 @@ export const inboxCommand = (messenger) => annotate(new Command("inbox"), {
     .option("--kind <kinds>", `only chats of these kinds, comma-separated: ${CHAT_KINDS.join(", ")}`)
     .option(...TRANSCRIBE_OPTION)
     .option(...MODEL_OPTION)
-    .addOption(ownerOnlyOption(...MARK_READ_OPTION))
-    .addOption(ownerOnlyOption(...NO_MARK_READ_OPTION))
+    .addHelpText("after", "To mark a chat read, use `chats mark-read <chat>`. The other side sees it.")
     .action(async function (query) {
-    const { new: fresh, all, kind, transcribe, model, markRead, } = this.opts();
+    const { new: fresh, all, kind, transcribe, model, } = this.opts();
     const hearWith = modelWith(transcribe, model);
     const context = messengerContext(this, messenger);
     const { app } = messenger;
@@ -64,8 +63,7 @@ export const inboxCommand = (messenger) => annotate(new Command("inbox"), {
         : undefined;
     const from = since ?? saved?.first;
     const points = saved?.chats;
-    const marking = marksRead(markRead, settings, this);
-    const { inbox, hearing, marked, reader } = await context.withServices(async (services, connect) => {
+    const { inbox, hearing, reader } = await context.withServices(async (services, connect) => {
         const inbox = await services.inbox.read({
             ...(from === undefined ? {} : { since: from }),
             ...(points === undefined ? {} : { points }),
@@ -76,11 +74,8 @@ export const inboxCommand = (messenger) => annotate(new Command("inbox"), {
         const reader = await services.messages.reader();
         const read = inbox.chats.flatMap((chat) => chat.messages.map((message) => ({ ...message, chatTitle: chat.title })));
         const hearing = await hearForCommand(context, messenger, read, transcribe === true, hearWith, connect);
-        const marked = marking ? await markShown(services, inbox.chats, renderer.warn) : undefined;
-        return { inbox, hearing, marked, reader };
+        return { inbox, hearing, reader };
     });
-    if (marked !== undefined)
-        renderer.note(`marked ${marked.length} chat(s) read up to the newest message shown`);
     if (inbox.partial && format === "pretty")
         renderer.warn(PARTIAL_NOTE);
     const answer = inboxAnswer(inbox, hearing, reader, transcribe === true, meta);

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

@@ -7,7 +7,7 @@ import { renderMessages } from "../../render/messages.js";
 import { renderThreadLinks } from "../../render/thread-context.js";
 import { readMail } from "../../services/mail-search.js";
 import { modelWith, spoken } from "../../speech/hearing.js";
-import { ownerOnlyOption, REMOTE_READ } from "../effects.js";
+import { REMOTE_READ } from "../effects.js";
 import { itemOf, listOf, renderAnswer } from "../envelope.js";
 import { queryHelp } from "../list-query.js";
 import { positiveCount } from "../paging.js";
@@ -48,29 +48,19 @@ export const messagesCommand = (messenger) => {
         .option("--cursor <cursor>", "go on from where the last page stopped; page.next gives it")
         .option(...TRANSCRIBE_OPTION)
         .option(...MODEL_OPTION)
-        .addOption(ownerOnlyOption("--mark-read", "also mark the chat read up to the newest message shown; the other person sees it"))
+        .addHelpText("after", "To mark a chat read, use `chats mark-read <chat>`. The other side sees it.")
         .action(async function (chat, query) {
         const context = messengerContext(this, messenger);
-        const { cursor, transcribe, model, markRead } = this.opts();
+        const { cursor, transcribe, model } = this.opts();
         const window = historyWindow(query, cursor, "messages list", history);
         const hearWith = modelWith(transcribe, model);
-        if (markRead && window.threadId !== undefined) {
-            throw new CliError("validation_error", "--mark-read marks the whole chat; use `chats mark-read --topic` for one");
-        }
-        if (markRead && context.settings.offline) {
-            throw new CliError("validation_error", "--mark-read tells the messenger; not with --offline");
-        }
         const { limit } = context.settings;
-        const { page, hearing, marked, reader } = await context.withServices(async (services, connect) => {
+        const { page, hearing, reader } = await context.withServices(async (services, connect) => {
             const page = await services.messages.list(chat, { limit, ...window });
             const reader = await services.messages.reader();
-            const newest = page.items.at(-1);
-            const marked = markRead && newest ? await services.chats.markRead({ chat, until: newest.id }) : undefined;
             const hearing = await hearForCommand(context, messenger, page.items, transcribe === true, hearWith, connect);
-            return { page, hearing, marked, reader };
+            return { page, hearing, reader };
         });
-        if (marked)
-            context.renderer.note(`marked read up to ${marked.until} (operation ${marked.operationId})`);
         const next = page.hasMore
             ? cursorOf(window, { first: page.items[0]?.id, last: page.items.at(-1)?.id })
             : undefined;

package/dist/cli/messenger/review.d.ts

@@ -5,7 +5,7 @@ export declare const unansweredHours: (value: unknown, flag?: string) => number;
 /**
  * **Everything said since a point, both sides, in every chat that changed** — the reading half of a
  * review of who owes what (max-cli's `review`). Sorting it is the reader's job, person or agent.
- * Nothing is marked read unless asked, and `inbox --new` keeps its point. The rules open and close
+ * Reading never marks a chat read, and `inbox --new` keeps its point. The rules open and close
  * tasks in the local store from what it read (`../../services/task-rules.ts`); nothing reaches the messenger.
  */
 export declare const reviewCommand: (messenger: Messenger) => Command;

package/dist/cli/messenger/review.js

@@ -6,10 +6,10 @@ import { renderMessages } from "../../render/messages.js";
 import { CHAT_KINDS } from "../../services/chats.js";
 import { kindsOf, REVIEW_DAYS, reviewStart, UNANSWERED_HOURS } from "../../services/inbox.js";
 import { modelWith } from "../../speech/hearing.js";
-import { ownerOnlyOption, REMOTE_READ } from "../effects.js";
+import { REMOTE_READ } from "../effects.js";
 import { renderAnswer } from "../envelope.js";
 import { queryHelp } from "../list-query.js";
-import { MARK_READ_OPTION, markShown, marksRead, NO_MARK_READ_OPTION, pointsOf } from "./catch-up.js";
+import { pointsOf } from "./catch-up.js";
 import { catchUpQuery, REVIEW_QUERY, reviewAnswer } from "./catch-up-answers.js";
 import { messengerContext } from "./context.js";
 import { heardItems, hearForCommand, MODEL_OPTION, spokenItems, TRANSCRIBE_OPTION } from "./hearing-command.js";
@@ -21,7 +21,7 @@ export const unansweredHours = (value, flag = "--unanswered") => value === true
 /**
  * **Everything said since a point, both sides, in every chat that changed** — the reading half of a
  * review of who owes what (max-cli's `review`). Sorting it is the reader's job, person or agent.
- * Nothing is marked read unless asked, and `inbox --new` keeps its point. The rules open and close
+ * Reading never marks a chat read, and `inbox --new` keeps its point. The rules open and close
  * tasks in the local store from what it read (`../../services/task-rules.ts`); nothing reaches the messenger.
  */
 export const reviewCommand = (messenger) => annotate(new Command("review"), {
@@ -38,8 +38,7 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
     .option(...TRANSCRIBE_OPTION)
     .option(...MODEL_OPTION)
     .option("--new", "what changed since the last `review --new`, a point per chat — for scheduled runs")
-    .addOption(ownerOnlyOption(...MARK_READ_OPTION))
-    .addOption(ownerOnlyOption(...NO_MARK_READ_OPTION))
+    .addHelpText("after", "To mark a chat read, use `chats mark-read <chat>`. The other side sees it.")
     .action(async function (query) {
     const options = this.opts();
     const hearWith = modelWith(options.transcribe, options.model);
@@ -59,12 +58,11 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
         })
         : undefined;
     const since = from ?? saved?.first ?? reviewStart();
-    const marking = marksRead(options.markRead, settings, this);
     const hours = options.unanswered === undefined ? undefined : unansweredHours(options.unanswered);
     const kinds = options.kind === undefined ? undefined : kindsOf(options.kind);
     let hearing;
     const transcribe = options.transcribe === true;
-    const { found, marked, reader } = await context.withServices(async (services, connect) => {
+    const { found, reader } = await context.withServices(async (services, connect) => {
         const found = await services.inbox.review({
             since,
             ...(saved === undefined ? {} : { points: saved.chats }),
@@ -84,13 +82,10 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
         });
         return {
             found,
-            marked: marking ? await markShown(services, found.chats, context.renderer.warn) : undefined,
             reader: await services.messages.reader(),
         };
     });
     found.complete &&= (hearing?.unheard.length ?? 0) === 0;
-    if (marked !== undefined)
-        renderer.note(`marked ${marked.length} chat(s) read up to the newest message shown`);
     notes(found, format === "pretty", renderer);
     renderAnswer(this, context, reviewAnswer(found, hearing, reader, {
         transcribe,

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -2,9 +2,9 @@ import { Command } from "commander";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
-    error?: undefined;
     path: string;
     exists: boolean;
+    error?: undefined;
 } | {
     path: string;
     exists: boolean;

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

@@ -2,7 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { TAGGING_QUERY } from "../../services/tags.js";
-import { LOCAL_READ, LOCAL_WRITE } from "../effects.js";
+import { changesStore, FETCH, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
 import { listQuery, pagedList, pageOf, typedQuery, withQuery } from "../list-query.js";
 import { positiveCount } from "../paging.js";
@@ -29,7 +29,7 @@ const sourceOf = (value) => {
 /** The owner's labels, in the local store only: `tag:` in a search finds what they label. */
 export const tagsCommand = (messenger) => {
     const tags = new Command("tags").description("your own labels on chats, people, messages and tasks, kept in the local store and never sent; tag: in a search finds them");
-    annotate(tags.command("auto"), { effects: LOCAL_WRITE })
+    changesStore(annotate(tags.command("auto"), { effects: FETCH }))
         .description("derive local group/channel tags from cached metadata using keyword rules")
         .option("--chat <chat>", "a stored group/channel; repeat to select several", (value, previous) => [...previous, value], [])
         .option("--limit <number>", "process at most 1–500 chats", positiveCount("--limit"), 50)

package/dist/cli/program.js

@@ -10,6 +10,7 @@ import { isCliFailure, isCommanderFailure } from "../errors/failures.js";
 import { failureContext } from "../errors/reasons.js";
 import { envName, readOnlyLockOf, readOnlyRefusal } from "../ports/app.js";
 import { recorded, wasSettled } from "../runs/recording.js";
+import { processRun, useAsProcessRun } from "../runs/scope.js";
 import { keyForCommand } from "../sends/permissions.js";
 import { logParsedArgv, logVersion } from "./argv-log.js";
 import { commandPathOf } from "./command-contract.js";
@@ -104,6 +105,15 @@ const RELAY_MARGIN_MS = 10_000;
  * message: it tells a script nothing it can branch on, and exits 1 for every kind of failure alike.
  */
 export const run = async (argv, definition, options = {}) => {
+    const outer = processRun();
+    try {
+        return await runOnce(argv, definition, options);
+    }
+    finally {
+        useAsProcessRun(outer);
+    }
+};
+const runOnce = async (argv, definition, options) => {
     const streams = options.streams ?? processStreams;
     if (!options.streams)
         quietBrokenPipes();

package/dist/cli/settings.d.ts

@@ -78,8 +78,6 @@ export interface Settings extends AISettings {
     /** Unset means "decide from the terminal", which is `resolveOutput`'s job, not this one's. */
     color: boolean | undefined;
     senderColors: boolean;
-    /** `inbox` and `review` mark each chat they show read, as `--mark-read` does; the other side sees it. Off unless set. */
-    catchUpMarksRead: boolean;
     searchCatchUp?: boolean;
     /** Search and `images embed` read the pictures themselves, with a model on this machine. Off until set. */
     pictureSearch?: boolean;
@@ -297,7 +295,6 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             requests_per_minute: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 0, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             transcribe_with: v.OptionalSchema<v.PicklistSchema<["auto", "messenger", "local"], (issue: v.BaseIssue<unknown>) => string>, undefined>;
             speech_model: v.OptionalSchema<v.StringSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
-            catch_up_marks_read: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             picture_search: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             update_check: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
@@ -427,7 +424,6 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             requests_per_minute: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 0, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             transcribe_with: v.OptionalSchema<v.PicklistSchema<["auto", "messenger", "local"], (issue: v.BaseIssue<unknown>) => string>, undefined>;
             speech_model: v.OptionalSchema<v.StringSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
-            catch_up_marks_read: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             picture_search: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
         }, (issue: v.StrictObjectIssue) => string>, "has to be an object of profiles, by name">, {}>;

package/dist/cli/settings.js

@@ -48,7 +48,6 @@ const SHARED_PROFILE_ENTRIES = {
     requests_per_minute: v.optional(countOrZero),
     transcribe_with: v.optional(v.picklist(["auto", "messenger", "local"], plain("has to be auto, messenger or local"))),
     speech_model: v.optional(v.string(plain("has to be a model id from `models audio list`, in quotes"))),
-    catch_up_marks_read: v.optional(flag),
     search_catch_up: v.optional(flag),
     picture_search: v.optional(flag),
     ...AI_ENTRIES,
@@ -116,7 +115,10 @@ export const settingsFor = (app, extension = {}) => {
             return loadSnakeCaseConfig(path, extension.schema ?? schema, () => ({ profiles: {} }));
         }
         catch (error) {
-            throw new CliError("configuration_error", error instanceof Error ? error.message : String(error));
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliError("configuration_error", message.includes("catch_up_marks_read")
+                ? `${message}; remove catch_up_marks_read from the config file and use ${app.command} <profile> chats mark-read <chat>`
+                : message);
         }
     };
     /**
@@ -187,13 +189,15 @@ export const settingsFor = (app, extension = {}) => {
             [extension.sourcePaths ? "config file: defaults" : "config defaults", shared],
         ];
         const fromLayers = (key, fallback, only = layers) => first(only.map(([from, scope]) => [from, scope?.[key]]), fallback);
+        if (fromLayers("catch_up_marks_read", undefined).value !== undefined) {
+            throw new CliError("configuration_error", `remove catch_up_marks_read from the config file and use ${app.command} <profile> chats mark-read <chat>`);
+        }
         const kindLayers = layers.filter(([from]) => from.startsWith(`config file: ${kind}.`));
         const limit = flags.limit === undefined ? fromLayers("limit", DEFAULT_LIMIT) : { value: flags.limit, from: "flag" };
         const record = flags.record === undefined ? fromLayers("record", false) : { value: flags.record, from: "flag" };
         const timeoutMs = fromLayers("timeout_ms", undefined);
         const color = fromLayers("color", undefined);
         const senderColors = fromLayers("sender_colors", false);
-        const catchUpMarksRead = fromLayers("catch_up_marks_read", false);
         const searchCatchUp = fromLayers("search_catch_up", false);
         const pictureSearch = fromLayers("picture_search", false);
         const keepRunsForDays = fromLayers("keep_runs_for_days", DEFAULT_KEEP_RUNS_FOR_DAYS);
@@ -241,7 +245,6 @@ export const settingsFor = (app, extension = {}) => {
             offline: flags.offline === true,
             color: color.value,
             senderColors: senderColors.value,
-            catchUpMarksRead: catchUpMarksRead.value,
             searchCatchUp: searchCatchUp.value,
             pictureSearch: pictureSearch.value,
             limit: limit.value,
@@ -275,7 +278,6 @@ export const settingsFor = (app, extension = {}) => {
                 commandTimeoutMs: timeout.from,
                 color: color.from,
                 senderColors: senderColors.from,
-                catchUpMarksRead: catchUpMarksRead.from,
                 searchCatchUp: searchCatchUp.from,
                 pictureSearch: pictureSearch.from,
                 record: record.from,

package/dist/meetings/index.d.ts

@@ -9,6 +9,7 @@ export { type Finding, type FindingsInput, type FindingsReceipt, type FindingsRu
 export { MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { type ImportFile, importFiles } from "./import.js";
 export { MEETING_ISSUES, MEETING_QUERY, type MeetingIssue, type MeetingItem, type MeetingOwner, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
+export { CHAT_MESSAGES_READ, type MeetingChatLine, type MeetingChatLinesInput, type MeetingChatLinesStore, } from "./links.js";
 export { createMeetingContext, MEETING_FACT_TYPES, type MeetingContextAction, type MeetingContextChange, type MeetingContextOperation, type MeetingContextPorts, type MeetingContextReceipt, validateMeetingContextChange, } from "./meeting-context.js";
 export { createMeetingManagement, dispatchMeetingMutation, type ManagedMeeting, type ManagedMeetingChange, type MeetingManagement, type MeetingManagementPorts, type MeetingMutationOptions, type MeetingMutationProposal, type MeetingMutationReceipt, type MeetingOperationOptions, type MeetingProviderContext, validateMeetingChange, } from "./meeting-management.js";
 export type { Attachment, ChatLine, Event, EventSeries, JsonValue, Meeting, MeetingSeries, Metadata, Occurrence, Participant, RecordTimes, SourceChatLine, SourceMeeting, Summary, SummaryContent, Transcript, TranscriptLine, TranscriptRow, } from "./model.js";
@@ -32,6 +33,7 @@ export { parseRecordingSyncCheckpoint, type RecordingSyncCheckpoint, type Record
 export { type RecordingPartial, RecordingTransferError, type RecordingTransferResponse, type RecordingTransferSource, type RecordingTransferStorage, type RecordingTransferWriter, strongRecordingValidator, transferRecording, } from "./recording-transfer.js";
 export { canonicalMeetingReference, formatMeetingReference, type MeetingReference, parseMeetingReference, } from "./reference.js";
 export { type MeetingRelatedHistoryEntry, type MeetingRelatedHistoryRequest, type MeetingRelatedHistoryStore, validateMeetingRelatedHistory, } from "./related-history.js";
+export { type MeetingReview, type MeetingReviewInput, type MeetingReviewItem, type MeetingReviewSpeaker, type MeetingReviewStore, REVIEW_LIMIT, } from "./review.js";
 export { SAVE_HELP, SAVE_INSTRUCTION } from "./save-hints.js";
 export type { MeetingHitSearchRequest, MeetingSearchIndexInput, MeetingSearchIndexReceipt, MeetingSearchIndexStore, MeetingSearchOptions, MeetingSearchPage, MeetingSearchStore, } from "./search-store.js";
 export { validateMeetingHitSearch } from "./search-validation.js";

package/dist/meetings/index.js

@@ -7,6 +7,7 @@ export { findingFingerprint, validateFindings, } from "./findings-rules.js";
 export { MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { importFiles } from "./import.js";
 export { MEETING_ISSUES, MEETING_QUERY, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
+export { CHAT_MESSAGES_READ, } from "./links.js";
 export { createMeetingContext, MEETING_FACT_TYPES, validateMeetingContextChange, } from "./meeting-context.js";
 export { createMeetingManagement, dispatchMeetingMutation, validateMeetingChange, } from "./meeting-management.js";
 export { normalizeMeetingParticipantQuery, validateMeetingParticipantSearch, } from "./participant-search.js";
@@ -23,6 +24,7 @@ export { parseRecordingSyncCheckpoint, RecordingSyncError, recordingAssetFingerp
 export { RecordingTransferError, strongRecordingValidator, transferRecording, } from "./recording-transfer.js";
 export { canonicalMeetingReference, formatMeetingReference, parseMeetingReference, } from "./reference.js";
 export { validateMeetingRelatedHistory, } from "./related-history.js";
+export { REVIEW_LIMIT, } from "./review.js";
 export { SAVE_HELP, SAVE_INSTRUCTION } from "./save-hints.js";
 export { validateMeetingHitSearch } from "./search-validation.js";
 export { validateMeetingSeriesHistory, } from "./series-history.js";

package/dist/meetings/links.d.ts

@@ -0,0 +1,18 @@
+import type { MeetingStatsSelection } from "./stats.js";
+export interface MeetingChatLinesInput extends MeetingStatsSelection {
+    /** Most chat messages to read (default and at most 100000); more is an error, never a silent cut. */
+    maxMessages?: number;
+}
+/** One stored chat message with the meeting it was sent in. */
+export interface MeetingChatLine {
+    meetingId: number;
+    accountId: number;
+    title: string | null;
+    sentAt: number;
+    sender: string | null;
+    text: string;
+}
+export interface MeetingChatLinesStore {
+    meetingChatLines(input: MeetingChatLinesInput): Promise<MeetingChatLine[]>;
+}
+export declare const CHAT_MESSAGES_READ = 100000;

package/dist/meetings/links.js

@@ -0,0 +1 @@
+export const CHAT_MESSAGES_READ = 100_000;

package/dist/meetings/review.d.ts

@@ -0,0 +1,45 @@
+import type { MeetingStatsSelection } from "./stats.js";
+export interface MeetingReviewInput extends MeetingStatsSelection {
+    /** Most meetings, newest first (default 50, at most 200). */
+    limit?: number;
+}
+export interface MeetingReviewSpeaker {
+    name: string | null;
+    talkMs: number;
+}
+/** One meeting as a review shows it: what the store holds about it, never transcript text. */
+export interface MeetingReviewItem {
+    meetingId: number;
+    accountId: number;
+    title: string | null;
+    startedAt: number | null;
+    durationMs: number | null;
+    participantsCount: number | null;
+    projects: string[];
+    /** `null`: no current transcript. */
+    transcript: {
+        lines: number;
+        words: number;
+    } | null;
+    /** The three who talked longest, from the transcript. */
+    speakers: MeetingReviewSpeaker[];
+    /** The newest stored summary; `null` when the meeting has none. */
+    summary: {
+        source: string;
+        title: string | null;
+        overview: string | null;
+        nextSteps: string[];
+        url: string | null;
+    } | null;
+}
+export interface MeetingReview {
+    items: MeetingReviewItem[];
+    hasMore: boolean;
+}
+export interface MeetingReviewStore {
+    meetingReview(input: MeetingReviewInput): Promise<MeetingReview>;
+}
+export declare const REVIEW_LIMIT: {
+    readonly default: 50;
+    readonly most: 200;
+};

package/dist/meetings/review.js

@@ -0,0 +1 @@
+export const REVIEW_LIMIT = { default: 50, most: 200 };

package/dist/runs/recording.d.ts

@@ -19,6 +19,11 @@ export interface RecordingOptions {
     now?: () => Date;
     /** The caller's trace; otherwise the enclosing run's, otherwise `TRACEPARENT` from `env`. */
     traceId?: string;
+    /**
+     * A one-shot command prints its answer after the run ends, outside `inRun`: naming the run as the process's lets
+     * that answer's `meta.run_id` name the run `runs show` finds. Never in a server, where runs overlap.
+     */
+    processRun?: boolean;
 }
 /**
  * Runs one command with the diagnostics turned on, and **finalizes on every path**.