@wirecat/cli-core 0.576.0 → 0.578.0

package/CHANGELOG.md

@@ -5,7 +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.577.0 — 05.11.2026
+
+### Added
+
+- **Tasks keep their id in an outside service and the page they are about (store version 51).** `tasks.provider`
+  and `tasks.external_id` hold a task's id in a service such as Avito, Cian or hh.ru, given and shown as
+  `<service>:<id>` (`avito:4512345678`), so ids of two services never collide; several tasks may share one.
+  `tasks.source_url` and `orders.source_url` hold the http or https page a task or an order is about, such as an Avito
+  ad or an Amazon order; anything else is refused (`task.source-url`, `order.source-url`, `task.external-id`).
+  `TaskFields.externalId` and `sourceUrl` set them on create and edit, `null` clears them; `TaskDetails` and the
+  `task` entity carry `external_id` and `source_url`; `OrderInput` and `Order` carry `sourceUrl`. Mail findings take
+  `external_id` and `source_url` on a `task` and `source_url` on an `order`, and accepting keeps them. `minCompatible`
+  stays 34.
+- **The owner moves a holder's mail mark back: `messages reset`.** `--holder <name>` with `--since-time <time>` or
+  `--last <n>`, and `--dry-run` to count first; the answer (`mail_mark_reset`) says how many emails the holder reads
+  whole again, how many bulk ones come again as excerpts and how many are skipped again. It is owner only: no
+  proposal, refused under the read-only lock, for a scheduled holder and for an agent (`mail.reset-owner-only`); a
+  holder with no mark yet is `mail.no-mark`. `rewindMark` is the function under it, and `MailActivityStore` gets
+  `emailsBefore`.
+
+### Changed — may break callers
+
+- **`projects status` fits 4 KB of JSON and 1.5 KB compact on the status fixture (was 11.2 KB and 3.6 KB).** Most of
+  it was rows the owner would not call status. Each chat's row now carries what is said once per chat: `last` (the
+  newest message's ref, time and sender), `next`, `waiting_since`, `addressed`, `overdue`, and for a chat held in part
+  `held` and `sync_command`; the `last_message`, `reply_next` and `coverage` lists are gone, and the `last-message`
+  signal with them (reply-next already cites the newest message). Others' questions in a group with no role, and
+  others' promises found by words in a group or past the newest one per chat, are counted on the chat's row under
+  `unlisted` instead of listed. A listed item drops `signal` and `chat_title`, keeps `evidence` (now plain refs) only
+  when it cites more than `ref`, and `who` only when set. `signals` is `{ id: version }`; a chat row leaves out
+  `purpose` when one purpose was read, `project` when it is the root, and `attention` when it is 0. `--compact` leaves
+  out `project`, `window`, `purposes` and `signals` (new `RowShape.hidden`). The human form is unchanged.
 
 ## 0.576.0 — 05.11.2026
 

package/dist/cli/compact.d.ts

@@ -20,6 +20,8 @@ export interface RowShape {
     sections?: Readonly<Record<string, string>>;
     /** An item answer's fields printed whole, never cut: a cursor that is pasted back. */
     whole?: readonly string[];
+    /** An item answer's fields left out: bookkeeping an agent reads in `--json` if it ever needs it. */
+    hidden?: readonly string[];
 }
 export interface CompactOptions {
     /** IANA zone for times; the answer's `meta.timezone` wins. */

package/dist/cli/compact.js

@@ -357,7 +357,7 @@ export const compactText = (body, shape, options, rowsOf = rowsOfEntity()) => {
     }
     else if (isFields(body.item)) {
         const sections = shape.sections ?? {};
-        const rest = Object.fromEntries(Object.entries(body.item).filter(([name]) => !Object.hasOwn(sections, name)));
+        const rest = Object.fromEntries(Object.entries(body.item).filter(([name]) => !Object.hasOwn(sections, name) && !shape.hidden?.includes(name)));
         lines = blockOf(rest, chars, "", shape.whole).map(guarded);
         for (const [name, entity] of Object.entries(sections)) {
             const list = body.item[name];

package/dist/cli/findings-input.js

@@ -14,6 +14,8 @@ const keys = {
     supplier_name: "supplierName",
     order_date: "orderDate",
     fulfilled_date: "fulfilledDate",
+    external_id: "externalId",
+    source_url: "sourceUrl",
 };
 const parseFindingsJson = (text, label, validate) => {
     if (Buffer.byteLength(text, "utf8") > 65536)

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

@@ -161,6 +161,8 @@ const statusCommand = (messenger) => answerEntity(annotate(new Command("status")
     "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. " +
+    "Others' questions in a group with no role, and others' word-found promises in a group, are counted on " +
+    "the chat's row as unlisted, not listed. " +
     "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")

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

@@ -41,6 +41,8 @@ const card = (task) => [
     `due ${when(task.dueAt)}  next check ${when(task.nextCheckAt)}  source ${task.source ?? "—"}`,
     ...(task.priorityLabel === null ? [] : [`priority ${task.priorityLabel}`]),
     ...(task.agent === null ? [] : [`agent ${task.agent}`]),
+    ...(task.externalId === null ? [] : [`external id ${task.externalId}`]),
+    ...(task.sourceUrl === null ? [] : [`page ${task.sourceUrl}`]),
     ...(task.claimedBy === null ? [] : [`claimed by ${task.claimedBy} until ${when(task.claimedUntil)}`]),
     ...task.assignments.filter((one) => one.role === "assignee").map((one) => `assignee ${one.to}`),
     ...(task.closeSuggestion === null ? [] : [suggestionLine(task.closeSuggestion)]),

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

@@ -1,7 +1,9 @@
 import type { RowShape } from "./compact.js";
+/** Signals of one item per chat, drawn on the chat's row rather than as a list of their own. */
+export declare const ON_CHAT_ROW: ReadonlySet<string>;
 /**
- * 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.
+ * The compact row of each listed 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. */

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

@@ -1,22 +1,14 @@
-const where = [{ field: "ref" }, { field: ["chat_title", "chat"] }];
+const where = [{ field: "ref" }];
 const who = { field: ["who.owner", "who.name"], tag: "you" };
+/** Signals of one item per chat, drawn on the chat's row rather than as a list of their own. */
+export const ON_CHAT_ROW = new Set(["reply-next", "coverage"]);
 /**
- * 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.
+ * The compact row of each listed 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],
+        columns: [...where, { field: "at", as: "day" }, who],
         text: ["data.excerpt"],
     },
     "status.promises": {
@@ -50,21 +42,10 @@ export const STATUS_SIGNAL_ROWS = {
         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" },
@@ -82,10 +63,14 @@ export const STATUS_ROWS = {
         columns: [
             { field: "chat" },
             { field: "title" },
-            { field: "kind" },
             { field: "role" },
-            { field: "attention", as: "count", tag: "attention" },
-            { field: "why" },
+            { field: "next", prefix: "next" },
+            { field: "addressed.name" },
+            { field: "waiting_since", as: "day" },
+            { field: "overdue", tag: "overdue" },
+            { field: "held.messages", as: "count", tag: "held" },
+            { field: "unlisted.questions", as: "count", tag: "questions unlisted" },
+            { field: "unlisted.promises", as: "count", tag: "promises unlisted" },
         ],
     },
     "status.money": {
@@ -96,7 +81,6 @@ export const STATUS_ROWS = {
             { field: "rows", as: "count", tag: "rows" },
         ],
     },
-    "status.signal": { columns: [{ field: "id" }, { field: "version" }] },
     "status.out-of-scope": {
         columns: [
             { field: "chat" },

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

@@ -18,7 +18,7 @@ export interface ProjectStatusHints {
         chatId: Id;
     }, since: string) => NextStep | null;
 }
-/** The `project_status` answer drawn by `--compact`: each signal's list with that signal's row. */
+/** The `project_status` answer drawn by `--compact`: a row per chat, then each listed signal with its own row. */
 export declare const projectStatusRow: (signals: readonly {
     id: string;
 }[]) => RowShape;
@@ -31,10 +31,8 @@ export declare const projectStatusSchema: v.LooseObjectSchema<{
         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>;
+    /** Each signal's version, so a saved answer says which rules made it. */
+    readonly signals: v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>;
     readonly money: v.ArraySchema<v.StrictObjectSchema<{
         readonly direction: v.StringSchema<undefined>;
         readonly currency: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -46,11 +44,33 @@ export declare const projectStatusSchema: v.LooseObjectSchema<{
         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 purpose: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly project: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
         readonly coverage: v.StringSchema<undefined>;
-        readonly attention: v.NumberSchema<undefined>;
-        readonly why: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly attention: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly why: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly last: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly ref: v.StringSchema<undefined>;
+            readonly at: v.StringSchema<undefined>;
+            readonly who: v.StrictObjectSchema<{
+                readonly ref: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly owner: v.BooleanSchema<undefined>;
+            }, undefined>;
+        }, undefined>, undefined>;
+        readonly next: v.OptionalSchema<v.PicklistSchema<["owner", "them", "named", "nobody"], undefined>, undefined>;
+        readonly waiting_since: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly addressed: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly ref: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly overdue: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly held: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly messages: v.NumberSchema<undefined>;
+            readonly oldest_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly sync_command: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly unlisted: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>, undefined>;
     }, undefined>, undefined>;
     readonly purposes: v.UnionSchema<[v.LiteralSchema<"all", undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>;
     readonly out_of_scope: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
@@ -85,9 +105,8 @@ export declare const projectStatusAnswer: (found: ProjectStatus, hints: ProjectS
             until: string;
         };
         signals: {
-            id: string;
-            version: number;
-        }[];
+            [x: string]: number;
+        };
         money: {
             direction: string;
             currency: string | null;
@@ -99,11 +118,35 @@ export declare const projectStatusAnswer: (found: ProjectStatus, hints: ProjectS
             title: string | null;
             kind: string;
             role: string | null;
-            purpose: string;
-            project: string;
+            purpose?: string | undefined;
+            project?: string | undefined;
             coverage: string;
-            attention: number;
-            why: string | null;
+            attention?: number | undefined;
+            why?: string | undefined;
+            last?: {
+                ref: string;
+                at: string;
+                who: {
+                    ref?: string | undefined;
+                    name: string | null;
+                    owner: boolean;
+                };
+            } | undefined;
+            next?: "named" | "nobody" | "owner" | "them" | undefined;
+            waiting_since?: string | null | undefined;
+            addressed?: {
+                ref: string | null;
+                name: string | null;
+            } | undefined;
+            overdue?: boolean | undefined;
+            held?: {
+                messages: number;
+                oldest_at: string | null;
+            } | undefined;
+            sync_command?: string | null | undefined;
+            unlisted?: {
+                [x: string]: number;
+            } | undefined;
         }[];
         purposes: "all" | string[];
         out_of_scope?: {

package/dist/cli/project-status.js

@@ -1,32 +1,32 @@
 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";
+import { ON_CHAT_ROW, 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. */
+/** The `project_status` answer drawn by `--compact`: a row per chat, then each listed signal with its own row. */
 export const projectStatusRow = (signals) => ({
     columns: [],
+    hidden: ["project", "window", "purposes", "signals"],
     sections: {
         ...SECTIONS,
-        ...Object.fromEntries(signals.map(({ id }) => [listKey(id), `status.${id}`])),
+        ...Object.fromEntries(signals.flatMap(({ id }) => (ON_CHAT_ROW.has(id) ? [] : [[listKey(id), `status.${id}`]]))),
     },
 });
+const who = v.strictObject({ ref: v.optional(v.string()), name: v.nullable(v.string()), owner: v.boolean() });
 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()) })),
+    who: v.optional(who),
+    /** Every ref the item cites, when it cites more than `ref`. */
+    evidence: v.optional(v.array(v.string())),
     basis: v.picklist(["store", "fact", "task", "pattern"]),
     data: v.record(v.string(), v.unknown()),
 });
@@ -36,18 +36,27 @@ export const projectStatusSchema = v.looseObject({
     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() })),
+    /** Each signal's version, so a saved answer says which rules made it. */
+    signals: v.record(v.string(), 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(),
+        purpose: v.optional(v.string()),
+        project: v.optional(v.string()),
         coverage: v.string(),
-        attention: v.number(),
-        why: v.nullable(v.string()),
+        attention: v.optional(v.number()),
+        why: v.optional(v.string()),
+        last: v.optional(v.strictObject({ ref: v.string(), at: v.string(), who })),
+        next: v.optional(v.picklist(["owner", "them", "named", "nobody"])),
+        waiting_since: v.optional(v.nullable(v.string())),
+        addressed: v.optional(v.strictObject({ ref: v.nullable(v.string()), name: v.nullable(v.string()) })),
+        overdue: v.optional(v.boolean()),
+        held: v.optional(v.strictObject({ messages: v.number(), oldest_at: v.nullable(v.string()) })),
+        sync_command: v.optional(v.nullable(v.string())),
+        unlisted: v.optional(v.record(v.string(), v.number())),
     })),
     purposes: v.union([v.literal("all"), v.array(v.string())]),
     out_of_scope: v.optional(v.array(v.strictObject({
@@ -130,26 +139,86 @@ const missingOf = (found, hints) => {
         ...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;
+const whoOf = (one) => one === null ? {} : { who: { ...(one.ref === null ? {} : { ref: one.ref }), name: one.name, owner: one.owner } };
+/** An item as listed: its first ref, every ref only when there are more. */
+const listed = ({ signal: _signal, who, evidence, ...one }) => ({
+    ...one,
+    ref: evidence[0]?.ref ?? one.chat,
+    ...whoOf(who),
+    ...(evidence.length > 1 ? { evidence: evidence.map((each) => each.ref) } : {}),
+});
+/**
+ * Low signal items, counted on their chat's row instead of listed: questions others ask in a group with no role (a
+ * leads group's requests), promises found by words that others wrote in a group, and past the newest one per chat.
+ */
+const unlistedOf = (found) => {
+    const chats = new Map(found.chats.map((chat) => [chat.ref, chat]));
+    const patterned = new Set();
+    return new Set(found.items.filter((one) => {
+        const chat = one.chat === null ? undefined : chats.get(one.chat);
+        if (!chat)
+            return false;
+        if (one.signal === "questions")
+            return one.data.side === "theirs" && chat.role === null && chat.kind !== "dialog";
+        if (one.signal !== "promises" || one.basis !== "pattern")
+            return false;
+        if (chat.kind !== "dialog" && !one.who?.owner)
+            return true;
+        if (!patterned.has(chat.ref)) {
+            patterned.add(chat.ref);
+            return false;
+        }
+        return true;
+    }));
+};
+const counted = (items) => {
+    const counts = {};
+    for (const one of items)
+        counts[one.signal] = (counts[one.signal] ?? 0) + 1;
+    return counts;
+};
+// The newest held message is the row's `last`.
+const heldOf = (one) => {
+    const { messages, oldestAt } = one.data.held;
+    return { messages, oldestAt };
+};
+/** A chat with what is said once per chat: its newest message, whose move it is, and how much of it is held. */
+const chatRow = (found, hints, chat, unlisted) => {
+    const weight = found.attention.find((one) => one.chat === chat.ref);
+    const of = (signal) => found.items.find((one) => one.signal === signal && one.chat === chat.ref);
+    const reply = of("reply-next");
+    const held = of("coverage");
+    const sync = held && partial(found, chat) ? hints.sync(chat, day(found.window.since)) : null;
+    const replied = reply?.data;
+    return {
+        chat: chat.ref,
+        title: chat.title,
+        kind: chat.kind,
+        role: chat.role,
+        ...(Array.isArray(found.purposes) && found.purposes.length === 1 ? {} : { purpose: chat.purpose }),
+        ...(chat.project === found.project.ref ? {} : { project: chat.project }),
+        coverage: chat.coverage.completeness.state,
+        ...(weight ? { attention: weight.weight, why: weight.why } : {}),
+        ...(reply && replied
+            ? {
+                last: { ref: reply.evidence[0]?.ref, at: reply.at, ...whoOf(reply.who) },
+                next: replied.next,
+                ...(replied.next === "nobody" ? {} : { waitingSince: replied.waitingSince }),
+                ...(replied.addressed ? { addressed: replied.addressed } : {}),
+                ...(replied.overdue ? { overdue: true } : {}),
+            }
+            : {}),
+        ...(held ? { held: heldOf(held), syncCommand: sync ? hints.line(sync) : null } : {}),
+        ...(unlisted.length ? { unlisted: counted(unlisted) } : {}),
     };
-    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 unlisted = unlistedOf(found);
     const lists = Object.fromEntries(found.signals.flatMap(({ id }) => {
-        const items = found.items.filter((one) => one.signal === id).map(place);
+        if (ON_CHAT_ROW.has(id))
+            return [];
+        const items = found.items.filter((one) => one.signal === id && !unlisted.has(one)).map(listed);
         return items.length ? [[listKey(id), items]] : [];
     }));
     const item = snakeKeys({
@@ -157,19 +226,9 @@ export const projectStatusAnswer = (found, hints) => {
         key: found.project.key,
         name: found.project.name,
         window: found.window,
-        signals: found.signals,
+        signals: Object.fromEntries(found.signals.map(({ id, version }) => [id, version])),
         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,
-        })),
+        chats: found.chats.map((chat) => chatRow(found, hints, chat, [...unlisted].filter((one) => one.chat === chat.ref))),
         purposes: found.purposes,
         ...(found.outOfScope.length
             ? {
@@ -201,8 +260,8 @@ export const projectStatusAnswer = (found, hints) => {
 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 [last] = of("reply-next");
+    const reply = last?.data;
     const head = [
         `${chat.title ?? chat.ref} (${[chat.role ?? "no role", chat.kind].join(", ")})`,
         last

package/dist/domain/external-links.d.ts

@@ -0,0 +1,13 @@
+/** The outside service an external id belongs to: `avito`, `cian`, `amazon`, `hh`. */
+export declare const EXTERNAL_SERVICE: RegExp;
+export declare const EXTERNAL_ID_CHARS = 200;
+export declare const SOURCE_URL_CHARS = 2000;
+export interface ExternalId {
+    provider: string;
+    id: string;
+}
+/** `avito:4512345678` → the service and its id; the id is everything after the first colon. */
+export declare const externalIdOf: (value: string) => ExternalId;
+export declare const externalIdText: (provider: unknown, id: unknown) => string | null;
+/** An http or https address, as given; anything else is refused, so a stored link always opens a web page. */
+export declare const sourceUrlOf: (value: string, reason?: string) => string;

package/dist/domain/external-links.js

@@ -0,0 +1,30 @@
+import { CliError } from "@wirecat/cli-base";
+/** The outside service an external id belongs to: `avito`, `cian`, `amazon`, `hh`. */
+export const EXTERNAL_SERVICE = /^[a-z][a-z0-9-]{0,31}$/;
+export const EXTERNAL_ID_CHARS = 200;
+export const SOURCE_URL_CHARS = 2000;
+/** `avito:4512345678` → the service and its id; the id is everything after the first colon. */
+export const externalIdOf = (value) => {
+    const text = value.trim();
+    const colon = text.indexOf(":");
+    const provider = colon === -1 ? "" : text.slice(0, colon).toLowerCase();
+    const id = colon === -1 ? "" : text.slice(colon + 1).trim();
+    if (!EXTERNAL_SERVICE.test(provider) || id.length === 0 || id.length > EXTERNAL_ID_CHARS || /\s/.test(id))
+        throw new CliError("validation_error", `an external id is <service>:<id>, such as avito:4512345678, at most ${EXTERNAL_ID_CHARS} characters after the colon and no spaces, not "${value}"`, { reason: "task.external-id" });
+    return { provider, id };
+};
+export const externalIdText = (provider, id) => provider == null || id == null ? null : `${String(provider)}:${String(id)}`;
+/** An http or https address, as given; anything else is refused, so a stored link always opens a web page. */
+export const sourceUrlOf = (value, reason = "task.source-url") => {
+    const text = value.trim();
+    let url;
+    try {
+        url = new URL(text);
+    }
+    catch {
+        url = undefined;
+    }
+    if (!url || (url.protocol !== "http:" && url.protocol !== "https:") || text.length > SOURCE_URL_CHARS)
+        throw new CliError("validation_error", `a source URL is an http or https address of at most ${SOURCE_URL_CHARS} characters, not "${value}"`, { reason });
+    return text;
+};

package/dist/entities/index.d.ts

@@ -4303,6 +4303,8 @@ export declare const ENTITIES: {
         readonly account: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
         readonly chat: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
         readonly source_message: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
+        readonly external_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly source_url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
         readonly priority: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
         readonly priority_label: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<readonly ["low", "medium", "high", "critical"], undefined>, undefined>, undefined>;
         readonly agent: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
@@ -4386,6 +4388,8 @@ export declare const ENTITIES: {
         readonly revision: v.NumberSchema<undefined>;
         readonly parent: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
         readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly external_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly source_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly due_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
         readonly next_check_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
         readonly closed_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
@@ -4500,6 +4504,8 @@ export declare const ENTITIES: {
             readonly revision: v.NumberSchema<undefined>;
             readonly parent: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
             readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly external_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly source_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly due_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
             readonly next_check_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
             readonly closed_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
@@ -4615,6 +4621,8 @@ export declare const ENTITIES: {
         readonly revision: v.NumberSchema<undefined>;
         readonly parent: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
         readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly external_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly source_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly due_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
         readonly next_check_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
         readonly closed_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
@@ -4758,6 +4766,8 @@ export declare const ENTITIES: {
             readonly revision: v.NumberSchema<undefined>;
             readonly parent: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
             readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly external_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly source_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly due_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
             readonly next_check_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
             readonly closed_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
@@ -4866,6 +4876,8 @@ export declare const ENTITIES: {
             readonly revision: v.NumberSchema<undefined>;
             readonly parent: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
             readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly external_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly source_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly due_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
             readonly next_check_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
             readonly closed_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
@@ -5911,6 +5923,8 @@ export declare const ENTITIES: {
                 readonly due_evidence: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
                 readonly assignee: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
                 readonly assignee_evidence: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
+                readonly external_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly source_url: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             }, undefined>, v.StrictObjectSchema<{
                 readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
                 readonly evidence: v.ArraySchema<v.StrictObjectSchema<{
@@ -6028,6 +6042,7 @@ export declare const ENTITIES: {
                 readonly invoice: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
                 readonly payment: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
                 readonly project: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+                readonly source_url: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                 readonly reason: v.StringSchema<undefined>;
             }, undefined>, v.StrictObjectSchema<{
                 readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;