@wirecat/cli-core 0.577.0 → 0.578.0

package/CHANGELOG.md

@@ -5,8 +5,6 @@ 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
@@ -27,6 +25,19 @@ shape of this file.
   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
 
 ### Added

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/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/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/services/project-status/signals/index.js

@@ -1,7 +1,6 @@
 import { amounts } from "./amounts.js";
 import { children } from "./children.js";
 import { coverage } from "./coverage.js";
-import { lastMessage } from "./last-message.js";
 import { payments } from "./payments.js";
 import { promises } from "./promises.js";
 import { questions } from "./questions.js";
@@ -9,7 +8,6 @@ import { replyNext } from "./reply-next.js";
 import { topics } from "./topics.js";
 /** The registry; its order is the answer's order. A new signal is one file here and its row in the CLI. */
 export const STATUS_SIGNALS = [
-    lastMessage,
     replyNext,
     questions,
     promises,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.577.0",
+  "version": "0.578.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",

package/dist/services/project-status/signals/last-message.d.ts

@@ -1,4 +0,0 @@
-import type { StatusSignal } from "../types.js";
-export type LastMessageData = Record<string, never>;
-/** The newest stored message in the window: when, and who wrote it. A chat held in part says so through `coverage`. */
-export declare const lastMessage: StatusSignal<LastMessageData>;

package/dist/services/project-status/signals/last-message.js

@@ -1,22 +0,0 @@
-import { evidenceOf, whoOf } from "../items.js";
-/** The newest stored message in the window: when, and who wrote it. A chat held in part says so through `coverage`. */
-export const lastMessage = {
-    id: "last-message",
-    version: 1,
-    scope: "chat",
-    read: async (_context, chat) => {
-        const last = chat?.messages.at(-1);
-        if (!chat || !last)
-            return [];
-        const item = {
-            signal: "last-message",
-            chat: chat.ref,
-            at: last.timestamp,
-            who: whoOf(last),
-            evidence: evidenceOf(chat, last),
-            basis: "store",
-            data: {},
-        };
-        return [item];
-    },
-};