@wirecat/cli-core 0.555.0 → 0.556.0

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

@@ -0,0 +1,184 @@
+import { annotate } from "@wirecat/cli-base/commands";
+import { formatLocator } from "../../domain/locator.js";
+import { storedChatId } from "../../services/message-resolution.js";
+import { momentOf } from "../../services/moment.js";
+import { ANALYSIS_PAGE, ANALYSIS_PAGE_MAX, acknowledgeTaskAnalysis, taskAnalysisList, unanalysedMessages, } from "../../services/task-analysis.js";
+import { TASK_QUERY } from "../../services/tasks.js";
+import { actorOf } from "../author.js";
+import { destroysNothing, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
+import { itemOf, renderAnswer } from "../envelope.js";
+import { listQuery, pagedList, pageOf, typedQuery } from "../list-query.js";
+import { positiveCount } from "../paging.js";
+import { nextStep } from "../steps.js";
+import { messengerContext, refuseLocalWrite } from "./context.js";
+const when = (at) => (at === null ? "—" : at.slice(0, 16).replace("T", " "));
+const sinceOf = (typed) => typed === undefined ? undefined : new Date(momentOf(typed, "--since-time")).toISOString();
+const markItem = (mark) => ({
+    chat: mark.chatId,
+    from: mark.from,
+    through: mark.through,
+    through_id: mark.throughId,
+    by: mark.by,
+    checked_at: mark.checkedAt,
+    checked_through: mark.checkedThrough,
+    at: mark.at,
+});
+const analysisItem = (chat) => ({
+    chat: chat.chatId,
+    title: chat.title,
+    kind: chat.kind,
+    newest_at: chat.newestAt,
+    mark: chat.mark === null ? null : markItem(chat.mark),
+    waiting: chat.waiting,
+    late: chat.late,
+    untrusted: ["title"],
+});
+/**
+ * Each chat's own point of reading for tasks (`../../services/task-analysis.ts`): how far it was read, what waits, and
+ * the step that moves it. Apart from `inbox --new`, `review --new` and the messenger's read state, which other
+ * readers move.
+ */
+export const analysisCommands = (tasks, messenger) => {
+    const tool = messenger.app.command;
+    annotate(tasks.command("status"), {
+        output: { entity: "task_analysis" },
+        effects: LOCAL_READ,
+        examples: [`${tool} personal tasks status`],
+    })
+        .summary("how far each chat was read for tasks, and how much waits")
+        .description("every chat that can hold your tasks — not a channel or Saved Messages — with the point its messages were read " +
+        "for tasks through, who read them, how many stored messages wait after it, and how many arrived late inside " +
+        "the stretch already read (history fetched afterwards). Its own point: reading a chat, marking it read, " +
+        "inbox --new and review --new never move it; tasks acknowledge does. Reads only the local store")
+        .option("--limit <n>", "how many chats", positiveCount("--limit"))
+        .action(async function () {
+        const context = messengerContext(this, messenger);
+        const { limit, offset } = pageOf(context.settings);
+        const chats = await context.withStore((store, account) => taskAnalysisList(store, account), {
+            name: "tasks status",
+        });
+        const shown = chats.slice(offset, offset + limit);
+        renderAnswer(this, context, pagedList("tasks status", context.settings, {
+            items: shown.map(analysisItem),
+            has_more: chats.length > offset + limit,
+        }), () => shown.length === 0
+            ? ""
+            : `${shown
+                .map((one) => `${(one.title ?? one.chatId).slice(0, 30).padEnd(30)}  read through ${when(one.mark?.through ?? null)}` +
+                `  ${one.waiting} waiting${one.late > 0 ? `, ${one.late} late` : ""}`)
+                .join("\n")}\n`);
+    });
+    annotate(tasks.command("review"), {
+        output: { entity: "task_review" },
+        effects: LOCAL_READ,
+        examples: [`${tool} personal tasks review <chat>`, `${tool} personal tasks review <chat> --since-time 30d`],
+    })
+        .summary("a chat's stored messages not yet read for tasks, with its open tasks")
+        .description("the stored messages after the chat's task point, oldest first, and the chat's open tasks, so one read can open " +
+        "new tasks and update or close the old ones. A chat never read starts 14 days back. Moves nothing: when done, " +
+        "tasks acknowledge <chat> <through> records it. Reads only the local store; messages sync or backfill fetch " +
+        "what it lacks")
+        .argument("<chat>", messenger.chatArgument)
+        .option("--limit <n>", `how many messages (default ${ANALYSIS_PAGE}, ${ANALYSIS_PAGE_MAX} with --since-time; at most ${ANALYSIS_PAGE_MAX})`, positiveCount("--limit"))
+        .option("--since-time <time>", "read again from this ISO 8601 time, or 30d ago, whatever the point says; what the point already passed only " +
+        "updates and closes tasks, unless tasks add is given --open-new")
+        .action(async function (chat) {
+        const context = messengerContext(this, messenger);
+        const { sinceTime, ...options } = this.opts();
+        const since = sinceOf(sinceTime);
+        // A read again clears late messages only when one acknowledge covers the whole stretch, so it takes one page.
+        const limit = options.limit ?? (since === undefined ? ANALYSIS_PAGE : ANALYSIS_PAGE_MAX);
+        const { id, page, sourceOf } = await context.withStore(async (store, account) => {
+            const id = await storedChatId(messenger, chat, store, account, { includeLeft: true });
+            return {
+                id,
+                page: await unanalysedMessages(store, account, id, {
+                    limit: Math.min(limit, ANALYSIS_PAGE_MAX),
+                    ...(since === undefined ? {} : { since }),
+                }),
+                sourceOf: (message) => formatLocator({ ...account, chat: id, message }),
+            };
+        }, { name: "tasks review" });
+        const open = await context.withServices((services) => services.tasks.list({
+            query: listQuery(typedQuery([`chat:${JSON.stringify(id)}`, "state:open"]), TASK_QUERY, "tasks review"),
+            limit: 100,
+            offset: 0,
+        }));
+        const last = page.messages.at(-1);
+        renderAnswer(this, context, itemOf({
+            chat: id,
+            from: page.from,
+            mark: page.mark === null ? null : markItem(page.mark),
+            late: page.late,
+            has_more: page.more,
+            through: last ? sourceOf(last.id) : null,
+            messages: page.messages.map((one) => ({
+                ref: sourceOf(one.id),
+                at: one.timestamp,
+                sender: one.senderName,
+                outgoing: one.outgoing === true,
+                reply_to: one.replyTo?.id ?? one.replyToId ?? null,
+                text: one.text,
+            })),
+            open_tasks: open.items.map(({ key = null, kind, title, source_message }) => ({
+                key,
+                kind,
+                title,
+                source: source_message,
+            })),
+            untrusted: ["messages.text", "messages.sender"],
+        }, {
+            next: last && !(since !== undefined && page.more)
+                ? [
+                    nextStep("tasks.acknowledge", {
+                        args: { chat: id, message: last.id, since_time: since },
+                        values: { shown: page.messages.length },
+                    }),
+                ]
+                : [],
+        }), () => [
+            `from ${when(page.from)}: ${page.messages.length} message(s)${page.more ? ", more after them" : ""}` +
+                (page.late > 0
+                    ? `; ${page.late} arrived late inside the stretch read: --since-time ${page.mark?.from} reads it again`
+                    : ""),
+            ...page.messages.map((one) => `  ${when(one.timestamp)}  ${one.outgoing ? "you" : (one.senderName ?? "?")}: ${one.text.replace(/\s+/g, " ").slice(0, 100)}`),
+            `open tasks (${open.items.length})`,
+            ...open.items.map((task) => `  ${task.key}  ${task.kind}  ${task.title ?? ""}`),
+            ...(since !== undefined && page.more
+                ? [
+                    `this read again does not reach the point in one page: acknowledging it moves nothing and late ` +
+                        "messages stay until a later version pages a read again (tell the owner)",
+                ]
+                : last
+                    ? [`done reading: ${tool} tasks acknowledge ${id} ${last.id}`]
+                    : []),
+            "",
+        ].join("\n"));
+    });
+    destroysNothing(annotate(tasks.command("acknowledge"), {
+        output: { entity: "task_analysis_mark" },
+        effects: LOCAL_WRITE,
+        examples: [`${tool} personal tasks acknowledge <chat> <message>`],
+    }))
+        .summary("record that a chat was read for tasks through a message")
+        .description("moves the chat's task point to this message once its tasks are opened, updated or closed; it never moves " +
+        "back. With --since-time, the read started there: a read again from the start of the stretch clears what " +
+        "arrived late inside it")
+        .argument("<chat>", messenger.chatArgument)
+        .argument("<message>", "the id of the last message read, as tasks review shows it")
+        .option("--since-time <time>", "where the read started, when tasks review was given --since-time")
+        .action(async function (chat, message) {
+        const context = messengerContext(this, messenger);
+        refuseLocalWrite(context, messenger.app.command, "tasks.acknowledge");
+        const { sinceTime } = this.opts();
+        const since = sinceOf(sinceTime);
+        const by = actorOf(this);
+        const { mark, moved } = await context.withStore(async (store, account) => {
+            const id = await storedChatId(messenger, chat, store, account, { includeLeft: true });
+            return acknowledgeTaskAnalysis(store, account, id, message, { by, ...(since === undefined ? {} : { since }) });
+        }, { name: "tasks acknowledge" });
+        renderAnswer(this, context, itemOf({ ...markItem(mark), moved }), () => moved
+            ? `read for tasks from ${when(mark.from)} through ${when(mark.through)}\n`
+            : `already read through ${when(mark.through)}; the point stays\n`);
+    });
+};

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

@@ -5,6 +5,7 @@ import { readOnlyLockOf, readOnlyRefusal } from "../../ports/app.js";
 import { AGENDA_QUERY, agendaItem } from "../../services/agenda.js";
 import { storedChatId } from "../../services/message-resolution.js";
 import { aheadOf, momentOf } from "../../services/moment.js";
+import { refuseAlreadyRead } from "../../services/task-analysis.js";
 import { unlistedNote } from "../../services/task-categories.js";
 import { ARRIVAL_WINDOW, applyTaskRulesToChats } from "../../services/task-rules.js";
 import { CLAIM_LEASE_MS, closedStateOf, TASK_PAIR_QUERY, TASK_QUERY, taskLinkKindOf, taskTypeOf, } from "../../services/tasks.js";
@@ -18,6 +19,7 @@ import { positiveCount } from "../paging.js";
 import { messengerContext, refuseLocalWrite } from "./context.js";
 import { coverageGaps } from "./search-answers.js";
 import { refuseJsonl, taskStatsAnswer } from "./stats-answers.js";
+import { analysisCommands } from "./tasks-analysis-command.js";
 const line = ({ id, key, state, kind, group, createdAt, message, note }) => [
     key ?? id.slice(0, 8),
     state.padEnd(9),
@@ -175,11 +177,17 @@ export const tasksCommand = (messenger) => {
         .requiredOption("--type <type>", "the task's type: question, request, mention or promise", taskTypeOf)
         .requiredOption("--category <name>", categoryHelp)
         .option("--into <id>", "when tasks add listed tasks that may be the same job: link the message to this one instead of opening a task")
-        .option("--new", "when tasks add listed tasks that may be the same job: open the task anyway"), "send Alex the API token").action(async function (message) {
+        .option("--new", "when tasks add listed tasks that may be the same job: open the task anyway")
+        .option("--open-new", "open a task from a message the chat's task point already passed (a read again with tasks review " +
+        "--since-time); without it such a read only updates and closes tasks"), "send Alex the API token").action(async function (message) {
         const context = messengerContext(this, messenger);
         refuseLocalWrite(context, messenger.app.command, "tasks.add");
         const options = this.opts();
-        const { into, new: anyway, ...rest } = options;
+        const { into, new: anyway, openNew, ...rest } = options;
+        if (!openNew)
+            await context.withStore((store, account) => refuseAlreadyRead(store, account, message), {
+                name: "tasks add",
+            });
         const plan = planFrom(rest);
         const { task, created, attached, review, followUpOf, card: planned, } = await context.withServices((services) => services.tasks.add(message, options.type, writerOf(this), plan, {
             ...(into === undefined ? {} : { attach: into }),
@@ -440,6 +448,7 @@ export const tasksCommand = (messenger) => {
         }, { name: "tasks scan" });
         renderAnswer(this, context, listOf("tasks scan", { items: passes.map(snakeKeys), limit: passes.length, has_more: false }), () => `${passes.map((pass) => applyText(pass, yes, tool)).join("\n")}\n`);
     });
+    analysisCommands(tasks, messenger);
     destroysNothing(annotate(tasks.command("claim"), {
         output: { entity: "task_card" },
         effects: LOCAL_WRITE,

package/dist/cli/steps.js

@@ -209,6 +209,16 @@ export const STEPS = defineSteps([
         args: [],
         why: "serve still runs an older version; a restart runs the one installed now",
     },
+    {
+        id: "tasks.acknowledge",
+        command: "tasks acknowledge",
+        args: [
+            { name: "chat", required: true },
+            { name: "message", required: true },
+            { name: "since_time", required: false },
+        ],
+        why: "once the tasks these {shown} messages hold are opened, updated or closed, so the next review starts after them",
+    },
     {
         id: "search.meetings",
         command: "*",

package/dist/entities/index.d.ts

@@ -81,14 +81,14 @@ import { automaticTags, tagChange } from "./tag-change.js";
 import { tagging } from "./tagging.js";
 import { task } from "./task.js";
 import { taskPair } from "./task-pair.js";
-import { taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskScan, taskSimilar, taskUnmerge } from "./task-results.js";
+import { taskAnalysis, taskAnalysisMark, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskScan, taskSimilar, taskUnmerge } from "./task-results.js";
 import { topic } from "./topic.js";
 /**
  * One schema per thing a command can answer with. A command returns an entity or one of its views — a
  * subset of its fields, never a renamed one. Commands move onto these one by one; until then, a schema
  * is the target, not a description of today's output.
  */
-export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reaction, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, topicIcon, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
+export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reaction, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskAnalysis, taskAnalysisMark, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, topicIcon, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
 export declare const ENTITIES: {
     readonly meeting_ingestion: v.StrictObjectSchema<{
         readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -5696,6 +5696,68 @@ export declare const ENTITIES: {
             readonly category: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         }, undefined>, undefined>;
     }, undefined>;
+    readonly task_analysis: v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly kind: v.StringSchema<undefined>;
+        readonly newest_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 mark: v.NullableSchema<v.StrictObjectSchema<{
+            readonly chat: v.StringSchema<undefined>;
+            readonly from: 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`">]>;
+            readonly through: 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`">]>;
+            readonly through_id: v.StringSchema<undefined>;
+            readonly by: v.StringSchema<undefined>;
+            readonly checked_at: 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`">]>;
+            readonly checked_through: 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`">]>;
+            readonly at: 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>, undefined>;
+        readonly waiting: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly late: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+    readonly task_analysis_mark: v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly from: 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`">]>;
+        readonly through: 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`">]>;
+        readonly through_id: v.StringSchema<undefined>;
+        readonly by: v.StringSchema<undefined>;
+        readonly checked_at: 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`">]>;
+        readonly checked_through: 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`">]>;
+        readonly at: 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`">]>;
+        readonly moved: v.BooleanSchema<undefined>;
+    }, undefined>;
+    readonly task_review: v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly from: 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`">]>;
+        readonly mark: v.NullableSchema<v.StrictObjectSchema<{
+            readonly chat: v.StringSchema<undefined>;
+            readonly from: 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`">]>;
+            readonly through: 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`">]>;
+            readonly through_id: v.StringSchema<undefined>;
+            readonly by: v.StringSchema<undefined>;
+            readonly checked_at: 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`">]>;
+            readonly checked_through: 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`">]>;
+            readonly at: 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>, undefined>;
+        readonly late: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly has_more: v.BooleanSchema<undefined>;
+        readonly through: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly messages: v.ArraySchema<v.StrictObjectSchema<{
+            readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly at: 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`">]>;
+            readonly sender: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly outgoing: v.BooleanSchema<undefined>;
+            readonly reply_to: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly text: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly open_tasks: v.ArraySchema<v.StrictObjectSchema<{
+            readonly key: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly kind: v.StringSchema<undefined>;
+            readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
     readonly fact: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

package/dist/entities/index.js

@@ -87,14 +87,14 @@ import { automaticTags, tagChange } from "./tag-change.js";
 import { tagging } from "./tagging.js";
 import { task } from "./task.js";
 import { taskPair } from "./task-pair.js";
-import { taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskScan, taskSimilar, taskUnmerge, } from "./task-results.js";
+import { taskAnalysis, taskAnalysisMark, taskAnalysisMarkMoved, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskReview, taskScan, taskSimilar, taskUnmerge, } from "./task-results.js";
 import { topic } from "./topic.js";
 /**
  * One schema per thing a command can answer with. A command returns an entity or one of its views — a
  * subset of its fields, never a renamed one. Commands move onto these one by one; until then, a schema
  * is the target, not a description of today's output.
  */
-export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reaction, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, topicIcon, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
+export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reaction, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskAnalysis, taskAnalysisMark, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, topicIcon, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
 export const ENTITIES = {
     sync_progress: syncProgress,
     ...MEETING_RESULT_ENTITIES,
@@ -233,6 +233,9 @@ export const ENTITIES = {
     task_unmerge: taskUnmerge,
     task_categories: taskCategories,
     task_scan: taskScan,
+    task_analysis: taskAnalysis,
+    task_analysis_mark: taskAnalysisMarkMoved,
+    task_review: taskReview,
     fact,
     memory,
     meeting,

package/dist/entities/task-results.d.ts

@@ -587,3 +587,75 @@ export declare const taskScan: v.StrictObjectSchema<{
         readonly category: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     }, undefined>, undefined>;
 }, undefined>;
+export declare const taskAnalysisMark: v.StrictObjectSchema<{
+    readonly chat: v.StringSchema<undefined>;
+    readonly from: 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`">]>;
+    readonly through: 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`">]>;
+    readonly through_id: v.StringSchema<undefined>;
+    readonly by: v.StringSchema<undefined>;
+    readonly checked_at: 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`">]>;
+    readonly checked_through: 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`">]>;
+    readonly at: 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>;
+export declare const taskAnalysisMarkMoved: v.StrictObjectSchema<{
+    readonly chat: v.StringSchema<undefined>;
+    readonly from: 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`">]>;
+    readonly through: 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`">]>;
+    readonly through_id: v.StringSchema<undefined>;
+    readonly by: v.StringSchema<undefined>;
+    readonly checked_at: 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`">]>;
+    readonly checked_through: 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`">]>;
+    readonly at: 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`">]>;
+    readonly moved: v.BooleanSchema<undefined>;
+}, undefined>;
+export declare const taskAnalysis: v.StrictObjectSchema<{
+    readonly chat: v.StringSchema<undefined>;
+    readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly kind: v.StringSchema<undefined>;
+    readonly newest_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 mark: v.NullableSchema<v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly from: 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`">]>;
+        readonly through: 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`">]>;
+        readonly through_id: v.StringSchema<undefined>;
+        readonly by: v.StringSchema<undefined>;
+        readonly checked_at: 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`">]>;
+        readonly checked_through: 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`">]>;
+        readonly at: 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>, undefined>;
+    readonly waiting: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly late: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+export declare const taskReview: v.StrictObjectSchema<{
+    readonly chat: v.StringSchema<undefined>;
+    readonly from: 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`">]>;
+    readonly mark: v.NullableSchema<v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly from: 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`">]>;
+        readonly through: 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`">]>;
+        readonly through_id: v.StringSchema<undefined>;
+        readonly by: v.StringSchema<undefined>;
+        readonly checked_at: 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`">]>;
+        readonly checked_through: 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`">]>;
+        readonly at: 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>, undefined>;
+    readonly late: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly has_more: v.BooleanSchema<undefined>;
+    readonly through: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    readonly messages: v.ArraySchema<v.StrictObjectSchema<{
+        readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly at: 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`">]>;
+        readonly sender: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly outgoing: v.BooleanSchema<undefined>;
+        readonly reply_to: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly text: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly open_tasks: v.ArraySchema<v.StrictObjectSchema<{
+        readonly key: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly kind: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;

package/dist/entities/task-results.js

@@ -2,7 +2,7 @@ import * as v from "valibot";
 import { TASK_TYPES } from "../domain/knowledge.js";
 import { LINK_KINDS, LINK_SOURCES } from "../store/sqlite/link-kinds.js";
 import { PRIORITY_LABELS, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS } from "../tasks/index.js";
-import { count, id, reference, text, time } from "./fields.js";
+import { count, id, reference, text, time, untrusted } from "./fields.js";
 import { closeSuggestion } from "./task.js";
 import { taskPair } from "./task-pair.js";
 const nullableTime = v.nullable(time);
@@ -135,3 +135,42 @@ export const taskScan = v.strictObject({
     held_chats: v.optional(count),
     tasks: v.array(v.strictObject({ source: text, kind: v.picklist(TASK_KINDS), category: v.nullable(text) })),
 });
+export const taskAnalysisMark = v.strictObject({
+    chat: text,
+    from: time,
+    through: time,
+    through_id: text,
+    by: text,
+    checked_at: time,
+    checked_through: time,
+    at: time,
+});
+export const taskAnalysisMarkMoved = v.strictObject({ ...taskAnalysisMark.entries, moved: v.boolean() });
+export const taskAnalysis = v.strictObject({
+    chat: text,
+    title: v.nullable(text),
+    kind: text,
+    newest_at: nullableTime,
+    mark: v.nullable(taskAnalysisMark),
+    waiting: count,
+    late: count,
+    untrusted,
+});
+export const taskReview = v.strictObject({
+    chat: text,
+    from: time,
+    mark: v.nullable(taskAnalysisMark),
+    late: count,
+    has_more: v.boolean(),
+    through: v.nullable(reference),
+    messages: v.array(v.strictObject({
+        ref: reference,
+        at: time,
+        sender: v.nullable(text),
+        outgoing: v.boolean(),
+        reply_to: v.nullable(text),
+        text,
+    })),
+    open_tasks: v.array(v.strictObject({ key: v.nullable(text), kind: text, title: v.nullable(text), source: v.nullable(text) })),
+    untrusted,
+});

package/dist/errors/reasons.d.ts

@@ -7,7 +7,7 @@ export declare const REASONS: ErrorReason[];
  * Detail keys an error from this package may carry, until each is registered on its own reason. Not `cause`:
  * that can hold a provider's or SQLite's raw text.
  */
-export declare const DETAILS: readonly ["contracts", "calendars", "allowed", "alternative", "arguments", "at", "available", "batch", "budget", "built", "candidates", "chat", "chat_id", "cli", "complete", "emitted_bytes", "exact", "forum", "guide", "hint", "id", "index", "kind", "limit", "limit_source", "max_bytes", "model", "name", "operation_id", "operation_ids", "text_limit", "store_refused_in", "subtasks", "partial_output", "parent", "path", "permission", "person_ids", "previous_chat_id", "profiles", "provider_error", "provider", "recovery", "reference", "remembered", "retry_at", "retry_after_ms", "runtime", "saved", "scheduled_for", "script", "sent", "sent_count", "settlement_failed", "span", "sqlite", "stage", "standing", "state", "stderr", "term", "total", "upgraded", "wanted"];
+export declare const DETAILS: readonly ["contracts", "calendars", "allowed", "alternative", "arguments", "at", "available", "batch", "budget", "built", "candidates", "chat", "chat_id", "cli", "column", "complete", "emitted_bytes", "exact", "file", "forum", "guide", "hint", "id", "index", "kind", "limit", "limit_source", "line", "max_bytes", "model", "name", "operation_id", "operation_ids", "text_limit", "store_refused_in", "subtasks", "partial_output", "parent", "path", "permission", "person_ids", "previous_chat_id", "profiles", "provider_error", "provider", "recovery", "reference", "remembered", "retry_at", "retry_after_ms", "runtime", "saved", "scheduled_for", "script", "sent", "sent_count", "settlement_failed", "span", "sqlite", "stage", "standing", "state", "stderr", "term", "total", "upgraded", "wanted"];
 /** What a CLI adds to the shared registry: its own reasons, and the detail keys its adapters raise. */
 export interface AppErrors {
     reasons?: readonly ErrorReason[];

package/dist/errors/reasons.js

@@ -57,6 +57,11 @@ const OTHERS = [
     validation("push.too-many-files", "the folder holds more files than one push takes"),
     validation("push.unreadable", "the folder to push could not be read"),
     validation("spreadsheet.unreadable", "the workbook could not be read"),
+    [
+        "config.unrepairable",
+        "configuration_error",
+        "the settings file's damage has more than one reading; nothing was changed, so it is fixed by hand",
+    ],
     ["state.invalid", "configuration_error", "the saved sync state is unreadable or invalid; it is kept, not reset"],
     ["sync.partial", "provider_error", "some calendars did not sync; the next sync retries them"],
     validation("event.conflict", "the event changed at the provider since the last sync; sync and try again"),
@@ -188,6 +193,7 @@ const OTHERS = [
     validation("task.has-subtasks", "the task has subtasks; move or detach them before it moves to another project"),
     validation("task.is-subtask", "a subtask moves to another project only when it is detached from its parent in the same write"),
     validation("task.duplicate-candidates", "open tasks may be the same job: attach to one, or add it as new"),
+    validation("task.already-read", "the message was already read for tasks: a read again only updates and closes tasks unless --open-new"),
     validation("task.certainty-required", "an agent closes a task with its certainty, 0 to 1"),
     ["task.pair-decided", "permission_error", "the owner already decided the pair; an agent does not change it"],
     validation("task.no-close-suggestion", "the task has no agent's close waiting on the owner"),
@@ -245,9 +251,11 @@ export const DETAILS = [
     "chat",
     "chat_id",
     "cli",
+    "column",
     "complete",
     "emitted_bytes",
     "exact",
+    "file",
     "forum",
     "guide",
     "hint",
@@ -256,6 +264,7 @@ export const DETAILS = [
     "kind",
     "limit",
     "limit_source",
+    "line",
     "max_bytes",
     "model",
     "name",

package/dist/mail/cli/index.d.ts

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import { type MailServerAccess } from "../../mail/server-search.js";
 import type { AppIdentity } from "../../ports/app.js";
 import { type AccountKey, type MessageStore } from "../../store/store.js";
+export { mailMark, markItem, markText } from "./marks.js";
 export { MAIL_REVIEW_QUERY, MAIL_REVIEW_STEPS } from "./review.js";
 /** What a mail CLI hands the shared commands: how to open the store for one run, and whose mail it reads. */
 export interface MailReads {

package/dist/mail/cli/index.js

@@ -18,7 +18,9 @@ import { searchMailServer } from "../../mail/server-search.js";
 import { atDetail } from "../../output-detail.js";
 import { sourceKey } from "../../services/server-search.js";
 import { queryFilter, THREAD_COLUMNS } from "../../store/store.js";
+import { acknowledgeCommand } from "./marks.js";
 import { mailReviewCommand } from "./review.js";
+export { mailMark, markItem, markText } from "./marks.js";
 export { MAIL_REVIEW_QUERY, MAIL_REVIEW_STEPS } from "./review.js";
 /** A locked or broken store must fail the command, not read as "nothing stored yet". */
 const absentAccount = (error) => {
@@ -226,6 +228,7 @@ const messagesCommand = (mail) => {
             ? listOf("messages show", { items: shown, limit: Math.max(1, shown.length), has_more: false })
             : itemOf(shown.find((_, at) => emails[at]?.anchor) ?? shown[0]), () => shownText(emails));
     });
+    messages.addCommand(acknowledgeCommand(mail));
     return messages;
 };
 const mailThread = v.strictObject({

package/dist/mail/cli/marks.d.ts

@@ -0,0 +1,26 @@
+import { Command } from "commander";
+import * as v from "valibot";
+import { type MailMark } from "../marks.js";
+import type { MailReads } from "./index.js";
+/** A holder's mark as `--json`, `mail status` and MCP show it. */
+export declare const mailMark: v.StrictObjectSchema<{
+    readonly holder: v.StringSchema<undefined>;
+    readonly through_id: v.NumberSchema<undefined>;
+    readonly through_received_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly held: v.NumberSchema<undefined>;
+    readonly read: v.NumberSchema<undefined>;
+    readonly skipped: v.StrictObjectSchema<{
+        readonly bulk: v.NumberSchema<undefined>;
+        readonly envelope: v.NumberSchema<undefined>;
+        readonly partial: v.NumberSchema<undefined>;
+        readonly draft: v.NumberSchema<undefined>;
+    }, undefined>;
+    readonly updated_at: v.StringSchema<undefined>;
+}, undefined>;
+export declare const markItem: (mark: MailMark) => v.InferOutput<typeof mailMark>;
+export declare const markText: (mark: MailMark) => string;
+/**
+ * `messages acknowledge`: a holder says it is done with what `review --holder` gave it, and its mark moves there. It
+ * only moves the holder's own bookkeeping forward, so a read-only scheduled run may do it.
+ */
+export declare const acknowledgeCommand: (mail: MailReads) => Command;