@wirecat/cli-core 0.550.0 → 0.552.0

package/dist/calendar/windows-zones.generated.d.ts

@@ -0,0 +1 @@
+export declare const WINDOWS_ZONES: Readonly<Record<string, string>>;

package/dist/calendar/windows-zones.generated.js

@@ -0,0 +1,146 @@
+// Generated by scripts/windows-zones.ts from CLDR release-49 (Unicode License v3, THIRD_PARTY_NOTICES); do not edit by hand.
+// https://raw.githubusercontent.com/unicode-org/cldr/release-49/common/supplemental/windowsZones.xml
+export const WINDOWS_ZONES = {
+    "Afghanistan Standard Time": "Asia/Kabul",
+    "Alaskan Standard Time": "America/Anchorage",
+    "Alberta Standard Time": "America/Edmonton",
+    "Aleutian Standard Time": "America/Adak",
+    "Altai Standard Time": "Asia/Barnaul",
+    "Arab Standard Time": "Asia/Riyadh",
+    "Arabian Standard Time": "Asia/Dubai",
+    "Arabic Standard Time": "Asia/Baghdad",
+    "Argentina Standard Time": "America/Buenos_Aires",
+    "Astrakhan Standard Time": "Europe/Astrakhan",
+    "Atlantic Standard Time": "America/Halifax",
+    "AUS Central Standard Time": "Australia/Darwin",
+    "Aus Central W. Standard Time": "Australia/Eucla",
+    "AUS Eastern Standard Time": "Australia/Sydney",
+    "Azerbaijan Standard Time": "Asia/Baku",
+    "Azores Standard Time": "Atlantic/Azores",
+    "Bahia Standard Time": "America/Bahia",
+    "Bangladesh Standard Time": "Asia/Dhaka",
+    "Belarus Standard Time": "Europe/Minsk",
+    "Bougainville Standard Time": "Pacific/Bougainville",
+    "British Columbia Standard Time": "America/Vancouver",
+    "Canada Central Standard Time": "America/Regina",
+    "Cape Verde Standard Time": "Atlantic/Cape_Verde",
+    "Caucasus Standard Time": "Asia/Yerevan",
+    "Cen. Australia Standard Time": "Australia/Adelaide",
+    "Central America Standard Time": "America/Guatemala",
+    "Central Asia Standard Time": "Asia/Bishkek",
+    "Central Brazilian Standard Time": "America/Cuiaba",
+    "Central Europe Standard Time": "Europe/Budapest",
+    "Central European Standard Time": "Europe/Warsaw",
+    "Central Pacific Standard Time": "Pacific/Guadalcanal",
+    "Central Standard Time": "America/Chicago",
+    "Central Standard Time (Mexico)": "America/Mexico_City",
+    "Chatham Islands Standard Time": "Pacific/Chatham",
+    "China Standard Time": "Asia/Shanghai",
+    "Cuba Standard Time": "America/Havana",
+    "Dateline Standard Time": "Etc/GMT+12",
+    "E. Africa Standard Time": "Africa/Nairobi",
+    "E. Australia Standard Time": "Australia/Brisbane",
+    "E. Europe Standard Time": "Europe/Chisinau",
+    "E. South America Standard Time": "America/Sao_Paulo",
+    "Easter Island Standard Time": "Pacific/Easter",
+    "Eastern Standard Time": "America/New_York",
+    "Eastern Standard Time (Mexico)": "America/Cancun",
+    "Egypt Standard Time": "Africa/Cairo",
+    "Ekaterinburg Standard Time": "Asia/Yekaterinburg",
+    "Fiji Standard Time": "Pacific/Fiji",
+    "FLE Standard Time": "Europe/Kiev",
+    "Georgian Standard Time": "Asia/Tbilisi",
+    "GMT Standard Time": "Europe/London",
+    "Greenland Standard Time": "America/Godthab",
+    "Greenwich Standard Time": "Atlantic/Reykjavik",
+    "GTB Standard Time": "Europe/Bucharest",
+    "Haiti Standard Time": "America/Port-au-Prince",
+    "Hawaiian Standard Time": "Pacific/Honolulu",
+    "India Standard Time": "Asia/Calcutta",
+    "Iran Standard Time": "Asia/Tehran",
+    "Israel Standard Time": "Asia/Jerusalem",
+    "Jordan Standard Time": "Asia/Amman",
+    "Kaliningrad Standard Time": "Europe/Kaliningrad",
+    "Korea Standard Time": "Asia/Seoul",
+    "Libya Standard Time": "Africa/Tripoli",
+    "Line Islands Standard Time": "Pacific/Kiritimati",
+    "Lord Howe Standard Time": "Australia/Lord_Howe",
+    "Magadan Standard Time": "Asia/Magadan",
+    "Magallanes Standard Time": "America/Punta_Arenas",
+    "Manitoba Standard Time": "America/Winnipeg",
+    "Marquesas Standard Time": "Pacific/Marquesas",
+    "Mauritius Standard Time": "Indian/Mauritius",
+    "Middle East Standard Time": "Asia/Beirut",
+    "Montevideo Standard Time": "America/Montevideo",
+    "Morocco Standard Time": "Africa/Casablanca",
+    "Mountain Standard Time": "America/Denver",
+    "Mountain Standard Time (Mexico)": "America/Mazatlan",
+    "Myanmar Standard Time": "Asia/Rangoon",
+    "N. Central Asia Standard Time": "Asia/Novosibirsk",
+    "Namibia Standard Time": "Africa/Windhoek",
+    "Nepal Standard Time": "Asia/Katmandu",
+    "New Zealand Standard Time": "Pacific/Auckland",
+    "Newfoundland Standard Time": "America/St_Johns",
+    "Norfolk Standard Time": "Pacific/Norfolk",
+    "North Asia East Standard Time": "Asia/Irkutsk",
+    "North Asia Standard Time": "Asia/Krasnoyarsk",
+    "North Korea Standard Time": "Asia/Pyongyang",
+    "Omsk Standard Time": "Asia/Omsk",
+    "Pacific SA Standard Time": "America/Santiago",
+    "Pacific Standard Time": "America/Los_Angeles",
+    "Pacific Standard Time (Mexico)": "America/Tijuana",
+    "Pakistan Standard Time": "Asia/Karachi",
+    "Paraguay Standard Time": "America/Asuncion",
+    "Qyzylorda Standard Time": "Asia/Qyzylorda",
+    "Romance Standard Time": "Europe/Paris",
+    "Russia Time Zone 10": "Asia/Srednekolymsk",
+    "Russia Time Zone 11": "Asia/Kamchatka",
+    "Russia Time Zone 3": "Europe/Samara",
+    "Russian Standard Time": "Europe/Moscow",
+    "SA Eastern Standard Time": "America/Cayenne",
+    "SA Pacific Standard Time": "America/Bogota",
+    "SA Western Standard Time": "America/La_Paz",
+    "Saint Pierre Standard Time": "America/Miquelon",
+    "Sakhalin Standard Time": "Asia/Sakhalin",
+    "Samoa Standard Time": "Pacific/Apia",
+    "Sao Tome Standard Time": "Africa/Sao_Tome",
+    "Saratov Standard Time": "Europe/Saratov",
+    "SE Asia Standard Time": "Asia/Bangkok",
+    "Singapore Standard Time": "Asia/Singapore",
+    "South Africa Standard Time": "Africa/Johannesburg",
+    "South Sudan Standard Time": "Africa/Juba",
+    "Sri Lanka Standard Time": "Asia/Colombo",
+    "Sudan Standard Time": "Africa/Khartoum",
+    "Syria Standard Time": "Asia/Damascus",
+    "Taipei Standard Time": "Asia/Taipei",
+    "Tasmania Standard Time": "Australia/Hobart",
+    "Tocantins Standard Time": "America/Araguaina",
+    "Tokyo Standard Time": "Asia/Tokyo",
+    "Tomsk Standard Time": "Asia/Tomsk",
+    "Tonga Standard Time": "Pacific/Tongatapu",
+    "Transbaikal Standard Time": "Asia/Chita",
+    "Turkey Standard Time": "Europe/Istanbul",
+    "Turks And Caicos Standard Time": "America/Grand_Turk",
+    "Ulaanbaatar Standard Time": "Asia/Ulaanbaatar",
+    "US Eastern Standard Time": "America/Indianapolis",
+    "US Mountain Standard Time": "America/Phoenix",
+    UTC: "Etc/UTC",
+    "UTC-02": "Etc/GMT+2",
+    "UTC-08": "Etc/GMT+8",
+    "UTC-09": "Etc/GMT+9",
+    "UTC-11": "Etc/GMT+11",
+    "UTC+12": "Etc/GMT-12",
+    "UTC+13": "Etc/GMT-13",
+    "Venezuela Standard Time": "America/Caracas",
+    "Vladivostok Standard Time": "Asia/Vladivostok",
+    "Volgograd Standard Time": "Europe/Volgograd",
+    "W. Australia Standard Time": "Australia/Perth",
+    "W. Central Africa Standard Time": "Africa/Lagos",
+    "W. Europe Standard Time": "Europe/Berlin",
+    "W. Mongolia Standard Time": "Asia/Hovd",
+    "West Asia Standard Time": "Asia/Tashkent",
+    "West Bank Standard Time": "Asia/Hebron",
+    "West Pacific Standard Time": "Pacific/Port_Moresby",
+    "Yakutsk Standard Time": "Asia/Yakutsk",
+    "Yukon Standard Time": "America/Whitehorse",
+};

package/dist/cli/compact.js

@@ -2,6 +2,7 @@ import { visibleControls } from "@wirecat/cli-base";
 import { metaOf } from "@wirecat/cli-base/commands";
 import { ENTITIES } from "../entities/index.js";
 import { answerRow } from "./answer-entity.js";
+import { STATUS_ROWS } from "./project-status-rows.js";
 export const TEXT_CHARS = 400;
 const sender = { field: ["sender_is_me", "sender_name"], tag: "me" };
 const messageRow = {
@@ -39,6 +40,7 @@ export const SHARED_ROWS = {
             { field: "last_message_at", as: "time" },
         ],
     },
+    ...STATUS_ROWS,
 };
 /** Any record: what names it, what it is called, what state it is in, then what it says. */
 export const GENERIC_ROW = {

package/dist/cli/context.d.ts

@@ -64,6 +64,8 @@ export interface BaseEnvironment {
      * message was handled, and nothing was sent" instead of on the next event or a sleep.
      */
     handled?: (event: MessageEvent) => void;
+    /** A test's hook into `serve`: how long it waits after connecting before its catch-up pass. */
+    startSyncDelayMs?: number;
     /** Set by an MCP server on a command it runs for an agent (`runCommandForAgent`). */
     agent?: AgentRun;
     /** Set by `run()`: the words it was given, which a run keeps as `record_input` says (`maskArgv`). */

package/dist/cli/index.d.ts

@@ -111,10 +111,13 @@ export { type Saving, stored } from "./messenger/stored.js";
 export { dateOrNone } from "./messenger/tasks-command.js";
 export { MODEL_CATALOGUE_QUERY, type ModelCatalogueOptions } from "./model-catalogue-command.js";
 export { positiveCount, window, withPaging } from "./paging.js";
+export { PAYMENT_QUERY_FIELDS, paymentFilterOf } from "./payment-query.js";
 export { type CommandPermissions, commandPathKey, commandPermissions, knownBeside, knownPermissionKeys, type PermissionKeyOf, type PermissionKeySource, refuseUnknownPermissionKeys, unknownPermissionIssues, unknownPermissionKeys, } from "./permission-keys.js";
 export { asFirstWord, commandWords, liftProfile, profileFree, refuseCommandName, rootOf, takesProfile, usableProfileName, } from "./profile.js";
 export { createProgram, type ProgramDefinition, type ProgramOptions, type RunOptions, run } from "./program.js";
 export { type ProjectTextHints, projectAnswerParts, projectCutoffTime, projectEvidenceText, projectWindowOf, withSyncCommands, } from "./project-evidence.js";
+export { type ProjectStatusHints, type ProjectStatusItem, projectStatusAnswer, projectStatusRow, projectStatusSchema, projectStatusText, } from "./project-status.js";
+export { STATUS_ROWS, STATUS_SIGNAL_ROWS } from "./project-status-rows.js";
 export { fieldsOf, projectFields } from "./result-fields.js";
 export type { ScheduleHost } from "./schedule/schedule-command.js";
 export { type Config, type Configuration, count, first, flag, fromFile, type GlobalFlags, NONE_NAMED, namedProfile, type ProfileKind, plain, type ResolveOptions, type Settings, type SettingsExtension, type SettingsExtensionContext, type Source, settingsFor, } from "./settings.js";

package/dist/cli/index.js

@@ -101,10 +101,13 @@ export { stored } from "./messenger/stored.js";
 export { dateOrNone } from "./messenger/tasks-command.js";
 export { MODEL_CATALOGUE_QUERY } from "./model-catalogue-command.js";
 export { positiveCount, window, withPaging } from "./paging.js";
+export { PAYMENT_QUERY_FIELDS, paymentFilterOf } from "./payment-query.js";
 export { commandPathKey, commandPermissions, knownBeside, knownPermissionKeys, refuseUnknownPermissionKeys, unknownPermissionIssues, unknownPermissionKeys, } from "./permission-keys.js";
 export { asFirstWord, commandWords, liftProfile, profileFree, refuseCommandName, rootOf, takesProfile, usableProfileName, } from "./profile.js";
 export { createProgram, run } from "./program.js";
 export { projectAnswerParts, projectCutoffTime, projectEvidenceText, projectWindowOf, withSyncCommands, } from "./project-evidence.js";
+export { projectStatusAnswer, projectStatusRow, projectStatusSchema, projectStatusText, } from "./project-status.js";
+export { STATUS_ROWS, STATUS_SIGNAL_ROWS } from "./project-status-rows.js";
 export { fieldsOf, projectFields } from "./result-fields.js";
 export { count, first, flag, fromFile, NONE_NAMED, namedProfile, plain, settingsFor, } from "./settings.js";
 export { readSetupAnswers, setupPermissionCeiling } from "./setup-answers.js";

package/dist/cli/meeting-findings-input.js

@@ -17,7 +17,8 @@ const parseFindingsJson = (text, label, validate) => {
     catch {
         throw new CliError("validation_error", `${label} input must be valid JSON`);
     }
-    const decode = (value, depth = 0) => {
+    // A payment keeps its snake_case fields: it is stored and printed as written.
+    const decode = (value, depth = 0, verbatim = false) => {
         if (depth > 16)
             throw new CliError("validation_error", `${label} JSON is nested too deeply`);
         if (Array.isArray(value))
@@ -28,10 +29,10 @@ const parseFindingsJson = (text, label, validate) => {
         for (const [key, item] of Object.entries(value)) {
             if (/[A-Z]/.test(key))
                 throw new CliError("validation_error", `${label} JSON fields use snake_case`);
-            const name = keys[key] ?? key;
+            const name = verbatim ? key : (keys[key] ?? key);
             if (Object.hasOwn(output, name))
                 throw new CliError("validation_error", `duplicate ${label} field`);
-            Object.defineProperty(output, name, { value: decode(item, depth + 1), enumerable: true });
+            Object.defineProperty(output, name, { value: decode(item, depth + 1, key === "payment"), enumerable: true });
         }
         return output;
     };

package/dist/cli/meeting-preparation-answer.d.ts

@@ -309,6 +309,9 @@ export declare const meetingPreparationAnswer: (packet: MeetingPreparation) => i
                 id: string;
                 excerpt: string;
                 offset_ms: number | null;
+                language?: string | null | undefined;
+                line?: number | undefined;
+                lines_total?: number | undefined;
                 match?: "corrected" | "words" | undefined;
                 corrections?: {
                     from: string;

package/dist/cli/meeting-preparation-projects.d.ts

@@ -29,6 +29,9 @@ export declare const mapPreparationProjectEvidence: (section: NonNullable<Meetin
             id: string;
             excerpt: string;
             offset_ms: number | null;
+            language?: string | null | undefined;
+            line?: number | undefined;
+            lines_total?: number | undefined;
             match?: "corrected" | "words" | undefined;
             corrections?: {
                 from: string;

package/dist/cli/meeting-preparation-read.d.ts

@@ -338,6 +338,9 @@ export declare const readMeetingPreparation: (read: MeetingPreparationReader, in
                 id: string;
                 excerpt: string;
                 offset_ms: number | null;
+                language?: string | null | undefined;
+                line?: number | undefined;
+                lines_total?: number | undefined;
                 match?: "corrected" | "words" | undefined;
                 corrections?: {
                     from: string;

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

@@ -33,6 +33,21 @@ import { stopOnSignal } from "./patience.js";
 const ALL_SINCE = "90d";
 /** What a background `--all` job is listed under; no chat argument is spelled like it. */
 const ALL_CHATS = "--all";
+/** Says where the history limits (history_* settings) stopped the read, so an agent does not take it for all. */
+const limitedLine = (result, status) => {
+    if ("items" in result) {
+        const { groupTooLarge = 0, olderThanWindow = 0 } = result.limited ?? {};
+        if (groupTooLarge + olderThanWindow === 0)
+            return undefined;
+        return (`the history limits (history_* settings) left ${groupTooLarge} big group(s) unread and read ${olderThanWindow} ` +
+            `chat(s) only to the window's start — \`${status}\` lists them; \`messages sync <chat> --full-history\` reads one in full`);
+    }
+    if (result.limited === "group_too_large")
+        return "not read: a group above history_group_members_max — `--full-history` reads it and keeps it in full";
+    if (result.limited === "older_than_window")
+        return "read to the history window's start (history_dialog_days / history_group_days) — `--full-history` reads further";
+    return undefined;
+};
 export const syncCommand = (messenger) => {
     const fetching = messenger.fetching ?? FETCHING;
     return annotate(new Command("sync"), {
@@ -58,7 +73,7 @@ export const syncCommand = (messenger) => {
         .option("--catch-up-chunks <n>", "at most this many local vector chunks", wholeNumber)
         .option("--catch-up-messages <n>", "skip a graph rebuild larger than this many messages", wholeNumber)
         .option("--catch-up-time <duration>", "local preparation time budget, 30s by default")
-        .option("--full-history", "keep this chat's pushed history in full from now on, past the history limits (history_* settings)")
+        .option("--full-history", "read and keep this chat's history in full from now on, past the history limits (history_* settings)")
         .option("--background", "run as a job that outlives this command; `store jobs show` follows it")
         .option("--dry-run", "only estimate how many messages, requests and minutes a full fetch would still take — from the store, no request")
         .action(async function (chat) {
@@ -151,6 +166,7 @@ export const syncCommand = (messenger) => {
                 limit,
                 pageSize,
                 pauseMs,
+                ...(include ? { fullHistory: true } : {}),
                 catchUp: prepare ? preparation : false,
                 ...(sinceMs === undefined ? {} : { sinceMs }),
                 ...(last === undefined ? {} : { last }),
@@ -191,9 +207,20 @@ export const syncCommand = (messenger) => {
                         ]
                         : []),
                     ...(toReview > 0 ? [nextStep("mentions.review", { args: { new: true }, values: { shown } })] : []),
+                    ...("limited" in result && result.limited && "chat" in result && result.chat
+                        ? [
+                            {
+                                ...nextStep("messages.sync", { args: { chat: result.chat, full_history: true } }),
+                                why: "reads this chat past the history limits and keeps it in full from now on",
+                            },
+                        ]
+                        : []),
                 ],
                 meta: window.meta,
             }));
+            const limitedNote = limitedLine(result, lineOf(this, "store status"));
+            if (limitedNote)
+                context.renderer.note(limitedNote);
             if (tasks?.held)
                 context.renderer.note(`the first sync left ${tasks.held} possible task(s) in ${tasks.heldChats ?? 0} chat(s) unopened ` +
                     `(config task_first_pass_per_chat) — ask the owner, then \`${lineOf(this, "tasks scan <chat>")}\``);

package/dist/cli/messenger/context.js

@@ -422,6 +422,7 @@ export const messengerContext = (command, messenger, resolving = {}) => {
                 // Turning recording off by name (--no-record, or record: false) keeps no search history either.
                 history: base.settings.record,
                 searchCatchUp: base.settings.searchCatchUp,
+                ...(base.settings.historyLimits ? { historyLimits: base.settings.historyLimits } : {}),
                 pictures: base.settings.pictureSearch,
                 reranker: base.settings.searchReranker,
                 guard,

package/dist/cli/messenger/history-gaps.js

@@ -1,7 +1,7 @@
 import { nextStep } from "../steps.js";
 const SHOWN = 5;
 const reasonOf = (skip) => skip.reason === "group_too_large"
-    ? `a group of ${skip.members ?? "many"} people, not saved`
+    ? `a group of ${skip.members ?? "many"} people, not ${skip.unread ? "read" : "saved"}`
     : `only from ${skip.keptFrom?.slice(0, 10) ?? "the window's start"}`;
 const nameOf = (skip) => skip.title ?? skip.chatId;
 /**
@@ -15,7 +15,7 @@ export const historyLimitGaps = (skips) => {
     const messages = skips.reduce((sum, skip) => sum + skip.messages, 0);
     const listed = skips
         .slice(0, SHOWN)
-        .map((skip) => `${nameOf(skip)} (${skip.messages}, ${reasonOf(skip)})`)
+        .map((skip) => `${nameOf(skip)} (${skip.messages > 0 ? `${skip.messages}, ` : ""}${reasonOf(skip)})`)
         .join("; ");
     const more = skips.length > SHOWN ? `; and ${skips.length - SHOWN} more — \`store status\` lists them` : "";
     return {
@@ -28,8 +28,8 @@ export const historyLimitGaps = (skips) => {
         missing: [
             {
                 field: "history_limits",
-                why: `the history limits (history_* settings) left ${messages} pushed messages of ${skips.length} chats out of ` +
-                    `the store: ${listed}${more}`,
+                why: `the history limits (history_* settings) left history of ${skips.length} chats out of the store` +
+                    `${messages > 0 ? ` (${messages} pushed messages counted)` : ""}: ${listed}${more}`,
                 step: "messages.sync",
             },
         ],

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

@@ -355,6 +355,7 @@ const serveProfiles = async (self, context, host, flags, set) => {
             tokenFile,
             lockFile: httpLockFile(tokenFile),
             version: app.version,
+            reaches: app.messenger === false ? `your ${host.name}` : "your messages",
             onCode: (code, expires) => context.renderer.note(env[mcpHttpMarker(app.envPrefix)] === undefined
                 ? `login code for a new browser app: ${code} (until ${expires.toTimeString().slice(0, 5)}; a new one after each login)`
                 : `a new login code for a browser app: \`${app.command} mcp server status --profiles ${set.option}\``),

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

@@ -26,14 +26,13 @@ export const deleteCommand = (messenger) => annotate(new Command("delete"), {
     if (environmentOf(this).agent && (everyone || messenger.deleteForMe === false))
         throw new CliError("permission_error", `${everyone ? "" : `${messenger.name ?? messenger.provider} deletes only for everyone, and `}an agent never ` +
             `deletes for everyone — the owner can run \`${lineOf(this, "messages delete --for-everyone")}\``, { permission: "messages.delete", sent: false });
+    const ids = messages
+        .flatMap((one) => one.split(","))
+        .map((one) => one.trim())
+        .filter(Boolean);
+    if (ids.length === 0)
+        throw new CliError("validation_error", "no message id given — name the messages to delete", { sent: false });
     const context = messengerContext(this, messenger);
-    const deleted = await context.withServices((services) => services.messages.delete({
-        chat,
-        messages: messages
-            .flatMap((one) => one.split(","))
-            .map((one) => one.trim())
-            .filter(Boolean),
-        forEveryone: everyone,
-    }));
+    const deleted = await context.withServices((services) => services.messages.delete({ chat, messages: ids, forEveryone: everyone }));
     renderAnswer(this, context, itemOf(snakeKeys(deleted)));
 });

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

@@ -3,12 +3,15 @@ import { annotate, annotateOption } from "@wirecat/cli-base/commands";
 import { Command, Option } from "commander";
 import { parseDuration } from "../../domain/duration.js";
 import { FETCHING } from "../../services/archive.js";
+import { projectStatus, STATUS_SIGNALS } from "../../services/project-status/index.js";
 import { gatherStoredProject } from "../../services/stored-project-gathering.js";
-import { FETCH } from "../effects.js";
+import { answerEntity } from "../answer-entity.js";
+import { FETCH, LOCAL_READ } from "../effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
 import { positiveCount } from "../paging.js";
 import { projectAnswerParts, projectCutoffTime, projectEvidenceText, projectWindowOf, withSyncCommands, } from "../project-evidence.js";
-import { lineOf } from "../steps.js";
+import { projectStatusAnswer, projectStatusRow, projectStatusSchema, projectStatusText } from "../project-status.js";
+import { lineOf, nextStep, rootOf, stepLine } from "../steps.js";
 import { messengerContext } from "./context.js";
 const collect = (value, previous) => [...previous, value];
 const upTo = (most, flag) => (value) => {
@@ -128,8 +131,50 @@ export const projectsCommand = (messenger) => {
         };
         renderAnswer(this, context, itemOf(snakeKeys(withSyncCommands(found, hints.sync)), parts), () => projectEvidenceText(found, hints));
     }));
+    projects.addCommand(statusCommand(messenger));
     return projects;
 };
+/** Where a project stands from this profile's stored messages: no model call, nothing leaves the machine. */
+const statusCommand = (messenger) => answerEntity(annotate(new Command("status"), {
+    examples: [`${messenger.app.command} personal projects status HRB --context-query 1C`],
+    effects: LOCAL_READ,
+    partial: true,
+})
+    .summary("where a project stands in this account's linked chats: whose move, open asks, money")
+    .description("per chat confirmed as the project's (and its child projects'), from what the store holds: the last message, " +
+    "who replies next, open questions both ways, promises, amounts with their direction, payments recorded, " +
+    "how long each --context-query has been quiet on their side, and how much of the chat is held. Amounts, " +
+    "directions and promises found by words are marked pattern: read the cited message before trusting one. " +
+    "Only this profile's account is read; the other linked chats are named, and memo projects status reads them")
+    .argument("<project>", "an existing project's id, key, exact name or alias")
+    .option("--since-time <time>", "how far back: days (60d, at most 730d) or a start date (2026-09-01)", "60d")
+    .option("--before-time <time>", "fixed exclusive end: ISO 8601 timestamp with UTC offset")
+    .option("--context-query <words>", "words that all appear in one text; reports their last mention per side. Repeat for another", collect, [])
+    .action(async function (project) {
+    const options = this.opts();
+    const context = messengerContext(this, messenger);
+    const found = await context.withStore((store, account) => projectStatus(store, {
+        project,
+        accounts: [account],
+        ...projectWindowOf(options.sinceTime),
+        ...(options.beforeTime === undefined ? {} : { asOf: projectCutoffTime(options.beforeTime) }),
+        contextQueries: options.contextQuery,
+    }));
+    const root = rootOf(this);
+    const hints = {
+        sync: (chat, since) => nextStep("messages.sync", { args: { chat: chat.chatId, since_time: since } }),
+        read: (chat, since) => nextStep("messages.list", { args: { chat: chat.chatId, query: `date>=${since}` } }),
+        line: (step) => (step.kind === "command" ? lineOf(this, wordsOf(root, step)) : step.why),
+    };
+    const { item, ...parts } = projectStatusAnswer(found, hints);
+    renderAnswer(this, context, itemOf(item, parts), () => projectStatusText(found, hints));
+}), "project_status", projectStatusSchema, { row: projectStatusRow(STATUS_SIGNALS) });
+/** A step's words after the tool and the profile, so `lineOf` names the profile the run used. */
+const wordsOf = (root, step) => {
+    const profile = root.getOptionValue("profile");
+    const typed = typeof profile === "string" && profile !== "" ? 2 : 1;
+    return stepLine(root, step).split(" ").slice(typed).join(" ");
+};
 const quote = (text) => (/^[\w:.-]+$/.test(text) ? text : `"${text.replace(/(["\\$`])/g, "\\$1")}"`);
 /** A line per saved page, counts only; a timed heartbeat with titles is the sync-progress work's (cli-core#2121). */
 const progressNote = (note) => ({ chat, index, of, fetched }) => note(`chat ${index + 1} of ${of} · ${chat} · ${fetched} messages so far`);

package/dist/cli/messenger/search-answers.js

@@ -293,7 +293,14 @@ export const allHitItem = (item) => item.kind === "meeting"
         offset_ms: item.startMs,
         scope: item.scope,
         id: String(item.id),
-        ...(item.cueRef === undefined ? {} : { cue_ref: item.cueRef, sender_name: item.speakerName ?? null }),
+        ...(item.cueRef === undefined
+            ? {}
+            : {
+                cue_ref: item.cueRef,
+                sender_name: item.speakerName ?? null,
+                language: item.language ?? null,
+                ...(item.line === undefined ? {} : { line: item.line, lines_total: item.linesTotal }),
+            }),
         untrusted: ALL_HIT_UNTRUSTED.meeting,
     }
     : defined({

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

@@ -0,0 +1,43 @@
+import type { Chat } from "../../domain/models.js";
+import type { ServeNotice } from "./serve-notice.js";
+/** The provider's own catch-up lands first; this pass then finds most chats already current. */
+export declare const START_SYNC_DELAY_MS = 30000;
+export declare const START_SYNC_BUDGET_MS: number;
+/** A longer downtime is `messages sync --all`'s job, not a start's. */
+export declare const START_SYNC_WINDOW_MS: number;
+export declare const START_SYNC_PER_CHAT = 500;
+export interface StartSyncSummary {
+    chats: number;
+    fetched: number;
+    failed: number;
+    stopped: boolean;
+}
+export interface StartSync {
+    /** Runs the pass once, after the delay; a second call is ignored. */
+    start(): void;
+    /** Aborts the pass and waits for it, which stops before its next request. */
+    stop(): Promise<void>;
+    summary(): StartSyncSummary | undefined;
+}
+/**
+ * `serve`'s one pass on start over the chats that moved while nothing listened. A provider's own
+ * catch-up drops a gap it finds too long (Telegram's `differenceTooLong`, `channelDifferenceTooLong`
+ * past 100 updates), so each chat whose newest message is newer than the newest one held is read back
+ * to that one. A chat never held is read back to the newest message held anywhere, which is about when
+ * the last serve stopped. Bounded by a window, a per-chat limit and a time budget; an empty store is
+ * left to `messages sync --all`.
+ */
+export declare const startSync: ({ chats, newestHeld, fetch, note, warn, delayMs, budgetMs, windowMs, now, }: {
+    chats: (stop: AbortSignal) => Promise<Chat[]>;
+    /** The newest message held from before this serve started, epoch milliseconds. */
+    newestHeld: (chatId: string) => Promise<number | undefined>;
+    fetch: (chatId: string, sinceMs: number, stop: AbortSignal) => Promise<{
+        fetched: number;
+    }>;
+    note: (notice: ServeNotice) => void;
+    warn: (notice: ServeNotice) => void;
+    delayMs?: number;
+    budgetMs?: number;
+    windowMs?: number;
+    now?: () => number;
+}) => StartSync;

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

@@ -0,0 +1,90 @@
+import { failureKey } from "../../errors/failures.js";
+/** The provider's own catch-up lands first; this pass then finds most chats already current. */
+export const START_SYNC_DELAY_MS = 30_000;
+export const START_SYNC_BUDGET_MS = 5 * 60_000;
+/** A longer downtime is `messages sync --all`'s job, not a start's. */
+export const START_SYNC_WINDOW_MS = 7 * 86_400_000;
+export const START_SYNC_PER_CHAT = 500;
+/**
+ * `serve`'s one pass on start over the chats that moved while nothing listened. A provider's own
+ * catch-up drops a gap it finds too long (Telegram's `differenceTooLong`, `channelDifferenceTooLong`
+ * past 100 updates), so each chat whose newest message is newer than the newest one held is read back
+ * to that one. A chat never held is read back to the newest message held anywhere, which is about when
+ * the last serve stopped. Bounded by a window, a per-chat limit and a time budget; an empty store is
+ * left to `messages sync --all`.
+ */
+export const startSync = ({ chats, newestHeld, fetch, note, warn, delayMs = START_SYNC_DELAY_MS, budgetMs = START_SYNC_BUDGET_MS, windowMs = START_SYNC_WINDOW_MS, now = Date.now, }) => {
+    const controller = new AbortController();
+    let timer;
+    let pass = Promise.resolve();
+    let started = false;
+    let done;
+    const run = async () => {
+        const stop = AbortSignal.any([controller.signal, AbortSignal.timeout(budgetMs)]);
+        const floor = now() - windowMs;
+        const moved = [];
+        for (const chat of await chats(stop)) {
+            const lastAt = Date.parse(chat.lastMessageAt ?? "");
+            if (Number.isNaN(lastAt) || lastAt < floor)
+                continue;
+            moved.push({ chat, lastAt, held: await newestHeld(chat.id) });
+        }
+        const anywhere = moved.reduce((top, { held }) => (held === undefined ? top : Math.max(top, held)), -Infinity);
+        if (!Number.isFinite(anywhere))
+            return;
+        const behind = moved
+            .filter(({ lastAt, held }) => lastAt > (held ?? anywhere))
+            .sort((one, other) => other.lastAt - one.lastAt);
+        if (behind.length === 0)
+            return;
+        const summary = { chats: 0, fetched: 0, failed: 0, stopped: false };
+        done = summary;
+        for (const { chat, held } of behind) {
+            if (stop.aborted)
+                break;
+            try {
+                summary.fetched += (await fetch(chat.id, Math.max(held ?? anywhere, floor), stop)).fetched;
+                summary.chats += 1;
+            }
+            catch (error) {
+                if (stop.aborted)
+                    break;
+                summary.failed += 1;
+                const errorCode = failureKey(error);
+                warn({
+                    code: "start_sync_chat_failed",
+                    chatId: chat.id,
+                    errorCode,
+                    text: `what ${chat.id} received while serve was down was not fetched: ${errorCode}`,
+                });
+            }
+        }
+        summary.stopped = stop.aborted && summary.chats + summary.failed < behind.length;
+        note({
+            code: "start_sync",
+            text: `caught up ${summary.fetched} message(s) in ${summary.chats} chat(s) that moved while serve was down` +
+                (summary.stopped ? ` — stopped at the time limit, ${behind.length - summary.chats - summary.failed} left` : ""),
+        });
+    };
+    return {
+        start: () => {
+            if (started || controller.signal.aborted)
+                return;
+            started = true;
+            timer = setTimeout(() => {
+                pass = run().catch((error) => {
+                    if (controller.signal.aborted)
+                        return;
+                    const errorCode = failureKey(error);
+                    warn({ code: "start_sync_failed", errorCode, text: `the catch-up on start failed: ${errorCode}` });
+                });
+            }, delayMs);
+        },
+        stop: async () => {
+            controller.abort();
+            clearTimeout(timer);
+            await pass;
+        },
+        summary: () => done,
+    };
+};