@wirecat/cli-core 0.549.0 → 0.551.0

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/payment-query.d.ts

@@ -0,0 +1,8 @@
+import type { PaymentFilter } from "../store/store.js";
+/**
+ * The terms a facts list adds for payments. `state` is the payment's, not `status`, which stays the review status
+ * (proposed, accepted).
+ */
+export declare const PAYMENT_QUERY_FIELDS: import("@wirecat/cli-base/query").FieldSpec[];
+/** The store's payment filter from `queryTerms`' answer; `undefined` when no payment term was given. */
+export declare const paymentFilterOf: (terms: Map<string, string>) => PaymentFilter | undefined;

package/dist/cli/payment-query.js

@@ -0,0 +1,27 @@
+import { CliError } from "@wirecat/cli-base";
+import { PAYMENT_DIRECTIONS, PAYMENT_STATES } from "../meetings/index.js";
+import { termField } from "./list-query.js";
+/**
+ * The terms a facts list adds for payments. `state` is the payment's, not `status`, which stays the review status
+ * (proposed, accepted).
+ */
+export const PAYMENT_QUERY_FIELDS = [
+    termField("open", "bool", "open:true"),
+    termField("direction", "enum", "direction:to_us", { values: PAYMENT_DIRECTIONS }),
+    termField("state", "enum", "state:paid", { values: PAYMENT_STATES }),
+];
+/** The store's payment filter from `queryTerms`' answer; `undefined` when no payment term was given. */
+export const paymentFilterOf = (terms) => {
+    const open = terms.get("open");
+    const direction = terms.get("direction");
+    const state = terms.get("state");
+    if (open === undefined && direction === undefined && state === undefined)
+        return undefined;
+    if (open !== undefined && open !== "true" && open !== "false")
+        throw new CliError("validation_error", "open takes true or false");
+    return {
+        ...(open === undefined ? {} : { open: open === "true" }),
+        ...(direction === undefined ? {} : { direction }),
+        ...(state === undefined ? {} : { state }),
+    };
+};

package/dist/cli/project-status-rows.d.ts

@@ -0,0 +1,8 @@
+import type { RowShape } from "./compact.js";
+/**
+ * The compact row of each status signal's items, by `status.<signal id>`; a signal's file and its row are the two
+ * places a new signal touches. They live here because a service may not import the CLI's row type.
+ */
+export declare const STATUS_SIGNAL_ROWS: Readonly<Record<string, RowShape>>;
+/** The rest of a `project_status` answer: its chats, open money, chats left out, and failed signals. */
+export declare const STATUS_ROWS: Readonly<Record<string, RowShape>>;

package/dist/cli/project-status-rows.js

@@ -0,0 +1,102 @@
+const where = [{ field: "ref" }, { field: ["chat_title", "chat"] }];
+const who = { field: ["who.owner", "who.name"], tag: "you" };
+/**
+ * The compact row of each status signal's items, by `status.<signal id>`; a signal's file and its row are the two
+ * places a new signal touches. They live here because a service may not import the CLI's row type.
+ */
+export const STATUS_SIGNAL_ROWS = {
+    "status.last-message": { columns: [...where, { field: "at", as: "time" }, who] },
+    "status.reply-next": {
+        columns: [
+            ...where,
+            { field: "data.next" },
+            { field: "data.addressed.name" },
+            { field: "data.waiting_since", as: "day" },
+            { field: "data.overdue", tag: "overdue" },
+        ],
+    },
+    "status.questions": {
+        columns: [...where, { field: "at", as: "day" }, { field: "data.side" }, who],
+        text: ["data.excerpt"],
+    },
+    "status.promises": {
+        columns: [
+            ...where,
+            { field: "at", as: "day" },
+            { field: "data.source" },
+            { field: "data.side" },
+            { field: "data.due", as: "day" },
+            { field: "data.status" },
+        ],
+        text: ["data.title"],
+    },
+    "status.amounts": {
+        columns: [
+            ...where,
+            { field: "data.direction" },
+            { field: "data.amount" },
+            { field: "data.currency" },
+            { field: "data.state" },
+            { field: "data.since", as: "day" },
+            { field: "data.asks", as: "count", tag: "asks" },
+            { field: "basis" },
+        ],
+    },
+    "status.payments": {
+        columns: [{ field: "ref" }, { field: "at", as: "day" }, { field: "data.status" }],
+        text: ["data.title"],
+    },
+    "status.topics": {
+        columns: [
+            ...where,
+            { field: "data.query" },
+            { field: "data.theirs_last", as: "day" },
+            { field: "data.yours_last", as: "day" },
+            { field: "data.silent_since", as: "day" },
+        ],
+    },
+    "status.coverage": {
+        columns: [
+            { field: "chat" },
+            { field: "chat_title" },
+            { field: "data.state" },
+            { field: "data.held.messages", as: "count", tag: "held" },
+            { field: "data.held.oldest_at", as: "day" },
+            { field: "sync_command" },
+        ],
+    },
+    "status.children": {
+        columns: [
+            { field: "data.child" },
+            { field: "data.key" },
+            { field: "data.name" },
+            { field: "data.chats", as: "count", tag: "chats" },
+            { field: "data.cut" },
+        ],
+    },
+};
+/** The rest of a `project_status` answer: its chats, open money, chats left out, and failed signals. */
+export const STATUS_ROWS = {
+    ...STATUS_SIGNAL_ROWS,
+    "status.chat": {
+        columns: [
+            { field: "chat" },
+            { field: "title" },
+            { field: "kind" },
+            { field: "role" },
+            { field: "attention", as: "count", tag: "attention" },
+            { field: "why" },
+        ],
+    },
+    "status.money": {
+        columns: [
+            { field: "direction" },
+            { field: "amount" },
+            { field: "currency" },
+            { field: "rows", as: "count", tag: "rows" },
+        ],
+    },
+    "status.signal": { columns: [{ field: "id" }, { field: "version" }] },
+    "status.out-of-scope": { columns: [{ field: "chat" }, { field: "reason" }, { field: "purpose" }] },
+    "status.failed": { columns: [{ field: "signal" }], text: ["why"] },
+};

package/dist/cli/project-status.d.ts

@@ -0,0 +1,132 @@
+import type { NextStep } from "@wirecat/cli-base/standards";
+import * as v from "valibot";
+import type { ProjectStatus, StatusChatSummary } from "../services/project-status/index.js";
+import type { RowShape } from "./compact.js";
+export interface ProjectStatusHints {
+    /** The step that syncs a chat held in part back to `since` (`YYYY-MM-DD`); null when no command here can. */
+    sync: (chat: StatusChatSummary, since: string) => NextStep | null;
+    /** The step that reads a chat's stored messages from `since`; null when no command here can. */
+    read: (chat: StatusChatSummary, since: string) => NextStep | null;
+    /** The command line a step runs, for the text form. */
+    line: (step: NextStep) => string;
+}
+/** The `project_status` answer drawn by `--compact`: each signal's list with that signal's row. */
+export declare const projectStatusRow: (signals: readonly {
+    id: string;
+}[]) => RowShape;
+/** Where a project stands: per chat signals, open money, and what was left out. Empty lists are left out. */
+export declare const projectStatusSchema: v.LooseObjectSchema<{
+    readonly project: v.StringSchema<undefined>;
+    readonly key: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly window: v.StrictObjectSchema<{
+        readonly since: v.StringSchema<undefined>;
+        readonly until: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly signals: v.ArraySchema<v.StrictObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly version: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly money: v.ArraySchema<v.StrictObjectSchema<{
+        readonly direction: v.StringSchema<undefined>;
+        readonly currency: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly amount: v.StringSchema<undefined>;
+        readonly rows: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly chats: v.ArraySchema<v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly kind: v.StringSchema<undefined>;
+        readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly purpose: v.StringSchema<undefined>;
+        readonly project: v.StringSchema<undefined>;
+        readonly coverage: v.StringSchema<undefined>;
+        readonly attention: v.NumberSchema<undefined>;
+        readonly why: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly out_of_scope: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly reason: v.StringSchema<undefined>;
+        readonly purpose: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly failed: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly signal: v.StringSchema<undefined>;
+        readonly why: v.StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+}, undefined>;
+export type ProjectStatusItem = v.InferOutput<typeof projectStatusSchema>;
+/** The answer of `projects status`: the item, two steps at most, what is missing, and the window. */
+export declare const projectStatusAnswer: (found: ProjectStatus, hints: ProjectStatusHints) => {
+    item: {
+        project: string;
+        key: string | null;
+        name: string;
+        window: {
+            since: string;
+            until: string;
+        };
+        signals: {
+            id: string;
+            version: number;
+        }[];
+        money: {
+            direction: string;
+            currency: string | null;
+            amount: string;
+            rows: number;
+        }[];
+        chats: {
+            chat: string;
+            title: string | null;
+            kind: string;
+            role: string | null;
+            purpose: string;
+            project: string;
+            coverage: string;
+            attention: number;
+            why: string | null;
+        }[];
+        out_of_scope?: {
+            chat: string;
+            reason: string;
+            purpose?: string | undefined;
+        }[] | undefined;
+        failed?: {
+            signal: string;
+            why: string;
+        }[] | undefined;
+    } & {
+        [key: string]: unknown;
+    };
+    next: ({
+        kind: "command";
+        step: string;
+        command: string;
+        args: {
+            [x: string]: unknown;
+        };
+        line?: string | undefined;
+        why: string;
+        safe_to_auto_execute: boolean;
+    } | {
+        kind: "user_action";
+        step: string;
+        why: string;
+        safe_to_auto_execute: false;
+    })[];
+    missing: {
+        field: string;
+        why: string;
+        step?: string | undefined;
+    }[];
+    meta: {
+        window: {
+            since: string;
+            until: string;
+        };
+        complete: boolean;
+        accounts?: string[] | undefined;
+    };
+};
+/** The human form: header, money, a line per chat with what is open, then the steps. */
+export declare const projectStatusText: (found: ProjectStatus, hints: ProjectStatusHints) => string;