@wirecat/cli-core 0.550.0 → 0.551.0

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;

package/dist/cli/project-status.js

@@ -0,0 +1,248 @@
+import * as v from "valibot";
+import { snakeKeys } from "./envelope.js";
+import { heldPhrase } from "./messenger/search-answers.js";
+import { STATUS_SIGNAL_ROWS } from "./project-status-rows.js";
+const day = (at) => new Date(at).toISOString().slice(0, 10);
+const listKey = (signal) => signal.replaceAll("-", "_");
+const SECTIONS = {
+    signals: "status.signal",
+    money: "status.money",
+    chats: "status.chat",
+    out_of_scope: "status.out-of-scope",
+    failed: "status.failed",
+};
+/** The `project_status` answer drawn by `--compact`: each signal's list with that signal's row. */
+export const projectStatusRow = (signals) => ({
+    columns: [],
+    sections: {
+        ...SECTIONS,
+        ...Object.fromEntries(signals.map(({ id }) => [listKey(id), `status.${id}`])),
+    },
+});
+const statusItem = v.looseObject({
+    signal: v.string(),
+    ref: v.nullable(v.string()),
+    chat: v.nullable(v.string()),
+    chat_title: v.nullable(v.string()),
+    at: v.nullable(v.string()),
+    who: v.nullable(v.strictObject({ ref: v.nullable(v.string()), name: v.nullable(v.string()), owner: v.boolean() })),
+    evidence: v.array(v.strictObject({ ref: v.string(), fingerprint: v.nullable(v.string()) })),
+    basis: v.picklist(["store", "fact", "task", "pattern"]),
+    data: v.record(v.string(), v.unknown()),
+});
+/** Where a project stands: per chat signals, open money, and what was left out. Empty lists are left out. */
+export const projectStatusSchema = v.looseObject({
+    project: v.string(),
+    key: v.nullable(v.string()),
+    name: v.string(),
+    window: v.strictObject({ since: v.string(), until: v.string() }),
+    signals: v.array(v.strictObject({ id: v.string(), version: v.number() })),
+    money: v.array(v.strictObject({ direction: v.string(), currency: v.nullable(v.string()), amount: v.string(), rows: v.number() })),
+    chats: v.array(v.strictObject({
+        chat: v.string(),
+        title: v.nullable(v.string()),
+        kind: v.string(),
+        role: v.nullable(v.string()),
+        purpose: v.string(),
+        project: v.string(),
+        coverage: v.string(),
+        attention: v.number(),
+        why: v.nullable(v.string()),
+    })),
+    out_of_scope: v.optional(v.array(v.strictObject({ chat: v.string(), reason: v.string(), purpose: v.optional(v.string()) }))),
+    failed: v.optional(v.array(v.strictObject({ signal: v.string(), why: v.string() }))),
+    ...Object.fromEntries(Object.keys(STATUS_SIGNAL_ROWS).map((name) => [listKey(name.slice(7)), v.optional(v.array(statusItem))])),
+});
+const coverageOf = (found, chat) => found.items.find((one) => one.signal === "coverage" && one.chat === chat)?.data;
+const partial = (found, chat) => {
+    const held = coverageOf(found, chat.ref);
+    return held ? held.state !== "complete" && held.beforeHeld : chat.coverage.completeness.state !== "complete";
+};
+const readFrom = (found, chat) => {
+    const reply = found.items.find((one) => one.signal === "reply-next" && one.chat === chat)?.data;
+    const money = found.items
+        .filter((one) => one.signal === "amounts" && one.chat === chat && one.data.state === "open")
+        .map((one) => one.data.since)
+        .sort()[0];
+    return day([money, reply?.waitingSince, found.window.since].find((one) => typeof one === "string"));
+};
+/** At most two: the chats `attention` weighs highest, a chat held in part synced first. */
+const nextOf = (found, hints) => {
+    const byRef = new Map(found.chats.map((chat) => [chat.ref, chat]));
+    const top = found.attention.slice(0, 2).flatMap((one) => {
+        const chat = byRef.get(one.chat);
+        return chat ? [{ chat, why: one.why }] : [];
+    });
+    const because = (step, why) => (step ? [{ ...step, why }] : []);
+    const syncs = top.flatMap(({ chat, why }) => partial(found, chat) ? because(hints.sync(chat, day(found.window.since)), why) : []);
+    const reads = top.flatMap(({ chat, why }) => partial(found, chat) ? [] : because(hints.read(chat, readFrom(found, chat.ref)), why));
+    return [...syncs, ...reads].slice(0, 2);
+};
+const missingOf = (found) => {
+    const held = found.chats.filter((chat) => partial(found, chat));
+    const [first] = held;
+    return [
+        ...(first
+            ? [
+                {
+                    field: "history",
+                    why: `${held.length} of ${found.chats.length} chats hold only part of the window; ` +
+                        `the first is ${heldPhrase(first.coverage)}`,
+                    step: "messages.sync",
+                },
+            ]
+            : []),
+        ...(found.outOfScope.length
+            ? [
+                {
+                    field: "chats",
+                    why: `${found.outOfScope.length} linked chats were not read here (${[
+                        ...new Set(found.outOfScope.map((one) => one.reason)),
+                    ].join(", ")}); memo projects status reads every account`,
+                },
+            ]
+            : []),
+        ...found.failed.map((one) => ({ field: `signal:${one.signal}`, why: one.why })),
+    ];
+};
+const withPlace = (found, hints) => {
+    const titles = new Map(found.chats.map((chat) => [chat.ref, chat.title]));
+    const sync = (one) => {
+        const chat = found.chats.find((each) => each.ref === one.chat);
+        const step = chat && partial(found, chat) ? hints.sync(chat, day(found.window.since)) : null;
+        return step ? hints.line(step) : null;
+    };
+    return (one) => ({
+        ...one,
+        ref: one.evidence[0]?.ref ?? one.chat,
+        chatTitle: one.chat === null ? null : (titles.get(one.chat) ?? null),
+        ...(one.signal === "coverage" ? { syncCommand: sync(one) } : {}),
+    });
+};
+/** The answer of `projects status`: the item, two steps at most, what is missing, and the window. */
+export const projectStatusAnswer = (found, hints) => {
+    const weights = new Map(found.attention.map((one) => [one.chat, one]));
+    const place = withPlace(found, hints);
+    const lists = Object.fromEntries(found.signals.flatMap(({ id }) => {
+        const items = found.items.filter((one) => one.signal === id).map(place);
+        return items.length ? [[listKey(id), items]] : [];
+    }));
+    const item = snakeKeys({
+        project: found.project.ref,
+        key: found.project.key,
+        name: found.project.name,
+        window: found.window,
+        signals: found.signals,
+        money: found.money.open,
+        chats: found.chats.map((chat) => ({
+            chat: chat.ref,
+            title: chat.title,
+            kind: chat.kind,
+            role: chat.role,
+            purpose: chat.purpose,
+            project: chat.project,
+            coverage: chat.coverage.completeness.state,
+            attention: weights.get(chat.ref)?.weight ?? 0,
+            why: weights.get(chat.ref)?.why ?? null,
+        })),
+        ...(found.outOfScope.length ? { outOfScope: found.outOfScope } : {}),
+        ...(found.failed.length ? { failed: found.failed } : {}),
+        ...lists,
+    });
+    const missing = missingOf(found);
+    const complete = found.failed.length === 0 && !found.chats.some((chat) => partial(found, chat));
+    return {
+        item,
+        next: nextOf(found, hints),
+        missing,
+        meta: { window: found.window, complete, ...(found.accounts.length ? { accounts: found.accounts } : {}) },
+    };
+};
+const NEXT_WORDS = { owner: "YOU", them: "them", nobody: "nobody" };
+const chatLine = (found, chat) => {
+    const of = (signal) => found.items.filter((one) => one.signal === signal && one.chat === chat.ref);
+    const [last] = of("last-message");
+    const reply = of("reply-next")[0]?.data;
+    const head = [
+        `${chat.title ?? chat.ref} (${[chat.role ?? "no role", chat.kind].join(", ")})`,
+        last
+            ? `last ${day(last.at)} ${last.who?.owner ? "you" : (last.who?.name ?? "them")}`
+            : "nothing in the window",
+        ...(reply
+            ? [
+                `next: ${reply.next === "named" ? `${reply.addressed?.name ?? "someone"} (named)` : NEXT_WORDS[reply.next]}` +
+                    (reply.waitingSince ? ` since ${day(reply.waitingSince)}` : ""),
+            ]
+            : []),
+        ...(partial(found, chat) ? [heldPhrase(chat.coverage)] : []),
+    ].join(" · ");
+    const open = [];
+    const asked = of("questions").map((one) => one.data);
+    const yours = asked.filter((one) => one.side === "yours").length;
+    const theirs = asked.length - yours;
+    if (theirs)
+        open.push(`${theirs} question${theirs === 1 ? "" : "s"} to you unanswered`);
+    if (yours)
+        open.push(`${yours} question${yours === 1 ? "" : "s"} of yours unanswered`);
+    for (const topic of of("topics")) {
+        const data = topic.data;
+        if (data.silentSince)
+            open.push(`"${data.query}" quiet on their side since ${day(data.silentSince)}`);
+    }
+    const promised = of("promises").length;
+    if (promised)
+        open.push(`${promised} promise${promised === 1 ? "" : "s"}`);
+    return [`  ${head}`, ...(open.length ? [`    open: ${open.join(" · ")}`] : [])];
+};
+const moneyLine = (one, titles) => {
+    const data = one.data;
+    const asks = data.asks > 1 && data.lastAsked ? ` (asked ${data.asks}×, last ${day(data.lastAsked)})` : "";
+    const where = one.chat === null ? "" : ` · ${titles.get(one.chat) ?? one.chat}`;
+    const words = data.direction.replace("_", " ");
+    const sum = `${data.amount} ${data.currency ?? "?"} ${data.state} since ${day(data.since)}`;
+    return `  ${words.padEnd(7)} ${sum}${asks}${where} · ${one.evidence[0]?.ref ?? ""} [${one.basis}]`;
+};
+/** The human form: header, money, a line per chat with what is open, then the steps. */
+export const projectStatusText = (found, hints) => {
+    const titles = new Map(found.chats.map((chat) => [chat.ref, chat.title]));
+    const { next } = projectStatusAnswer(found, hints);
+    const money = found.items.filter((one) => one.signal === "amounts" && one.data.state !== "mentioned");
+    const payments = found.items.filter((one) => one.signal === "payments");
+    const children = found.items.filter((one) => one.signal === "children");
+    const key = found.project.key ? `${found.project.key} · ` : "";
+    const lines = [
+        `${key}${found.project.name} · ${found.chats.length} linked chats in ${found.accounts.length} accounts, ` +
+            `${day(found.window.since)} to ${day(found.window.until)}`,
+    ];
+    if (money.length || payments.length) {
+        lines.push("Money");
+        for (const one of money)
+            lines.push(moneyLine(one, titles));
+        for (const one of payments) {
+            const data = one.data;
+            lines.push(`  payment ${data.title} · ${one.evidence[0]?.ref ?? ""} [${data.status}]`);
+        }
+    }
+    if (found.chats.length)
+        lines.push("Chats");
+    for (const chat of found.chats)
+        for (const line of chatLine(found, chat))
+            lines.push(line);
+    if (children.length)
+        lines.push("Children");
+    for (const one of children) {
+        const data = one.data;
+        const cut = one.data.cut;
+        lines.push(`  ${cut ? `${data.child} not read (${cut})` : `${data.key ?? data.child} · ${data.name} · ${data.chats} chats`}`);
+    }
+    if (found.outOfScope.length)
+        lines.push(`Not read here: ${found.outOfScope.map((one) => `${one.chat} (${one.reason})`).join(", ")}`);
+    for (const one of found.failed)
+        lines.push(`Signal ${one.signal} failed: ${one.why}`);
+    if (next.length)
+        lines.push("Next");
+    next.forEach((step, index) => {
+        lines.push(`  ${index + 1}. ${hints.line(step)}`);
+    });
+    return lines.join("\n");
+};

package/dist/cli/steps.js

@@ -48,7 +48,10 @@ export const STEPS = defineSteps([
     {
         id: "messages.list",
         command: "messages list",
-        args: [{ name: "chat", required: true }],
+        args: [
+            { name: "chat", required: true },
+            { name: "query", required: false },
+        ],
         why: "only the newest were read here; this reads the chat itself",
     },
     {

package/dist/domain/knowledge.d.ts

@@ -1,4 +1,4 @@
-export declare const FACT_TYPES: readonly ["fact", "statement", "question", "decision", "promise"];
+export { FACT_TYPES } from "../meetings/index.js";
 export declare const FACT_STATUSES: readonly ["proposed", "accepted", "superseded", "reversed", "rejected"];
 export declare const MEMORY_KINDS: readonly ["summary", "digest", "preference"];
 export declare const MEMORY_STATUSES: readonly ["proposed", "confirmed", "stale", "superseded"];

package/dist/domain/knowledge.js

@@ -1,5 +1,5 @@
 import { TASK_KINDS } from "../tasks/index.js";
-export const FACT_TYPES = ["fact", "statement", "question", "decision", "promise"];
+export { FACT_TYPES } from "../meetings/index.js";
 export const FACT_STATUSES = ["proposed", "accepted", "superseded", "reversed", "rejected"];
 export const MEMORY_KINDS = ["summary", "digest", "preference"];
 export const MEMORY_STATUSES = ["proposed", "confirmed", "stale", "superseded"];

package/dist/domain/status-words.d.ts

@@ -0,0 +1,3 @@
+export declare const MONEY_DONE_FORMS: RegExp;
+/** First person future: "I'll send", "сделаю", "lo envío". Labelled a guess wherever it is shown. */
+export declare const PROMISE_FORMS: RegExp;