@kingcrab/pi-imessage 1.0.0 → 1.1.1

package/dist/web/server.js

@@ -6,12 +6,12 @@ import { promisify } from "node:util";
 import { gzip } from "node:zlib";
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { LiveDoc, } from "@earendil-works/pi-durable";
-import { Chats } from "../agent/chats.js";
+import { Chats, progressEnabled } from "../agent/chats.js";
 import { DirectSends } from "../agent/direct-send.js";
 import { Sessions } from "../agent/health.js";
 import { Deliveries } from "../agent/replies.js";
 import { Schedules } from "../agent/scheduling.js";
-import { readSettings } from "../config/settings.js";
+import { isReplyEnabled, readSettings } from "../config/settings.js";
 import { displayHistory, historyActivity } from "./history.js";
 import { memoryPage, parseMemoryFile } from "./memory.js";
 import { renderPage } from "./page.js";
@@ -113,6 +113,36 @@ export async function startWeb(options) {
             settings: { chatAllowlist: configuration.chatAllowlist },
         };
     }
+    /** One row per chat: reply eligibility, the /verbose choice and the conversation's agent settings. */
+    async function chatSettings() {
+        const [chats, configuration] = await Promise.all([
+            options.agent.harness.snapshot(Chats, BACKGROUND_CONTEXT),
+            settings(),
+        ]);
+        const records = chats?.items ?? [];
+        const rows = await Promise.all(records.map(async (chat) => {
+            const conversation = await options.agent.harness.conversation(chat.conversationId, BACKGROUND_CONTEXT);
+            const [agent, entries] = conversation
+                ? await Promise.all([conversation.agent(BACKGROUND_CONTEXT), history(chat.conversationId)])
+                : [undefined, undefined];
+            return {
+                chatGuid: chat.chatGuid,
+                conversationId: chat.conversationId,
+                groupName: entries ? displayHistory(entries, 15).groupName : undefined,
+                updatedAt: entries ? historyActivity(entries) : undefined,
+                replies: isReplyEnabled(configuration, chat.chatGuid),
+                verbose: { chat: chat.progress, effective: progressEnabled(configuration, records, chat.chatGuid) },
+                model: agent?.model ? `${agent.model.provider}/${agent.model.modelId}` : undefined,
+                thinking: agent?.thinkingLevel,
+            };
+        }));
+        rows.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0) || Number(b.conversationId) - Number(a.conversationId));
+        return {
+            chats: rows,
+            defaults: { progressMessages: configuration.progressMessages },
+            revision: viewRevision(),
+        };
+    }
     const server = createServer((request, response) => {
         void handle(request, response).catch((error) => {
             if (!response.headersSent)
@@ -241,16 +271,31 @@ export async function startWeb(options) {
             value = await readSchedules(options.agent.harness);
             compact = true;
         }
+        else if (page === "/chats") {
+            value = await chatSettings();
+            compact = true;
+        }
         else if (page === "/tasks") {
             value = {
                 ...(await readTaskTree(options.agent.harness)),
                 schedules: await options.agent.harness.snapshot(Schedules, BACKGROUND_CONTEXT),
                 chats: await options.agent.harness.snapshot(Chats, BACKGROUND_CONTEXT),
                 sessions: await options.agent.harness.snapshot(Sessions, BACKGROUND_CONTEXT),
+                session: join(options.workingDir, "durable"),
                 revision: viewRevision(),
             };
             compact = true;
         }
+        else if (url.pathname === "/tasks/entry/data") {
+            const id = url.searchParams.get("entryId");
+            if (!id || !/^\d+$/.test(id) || !Number.isSafeInteger(Number(id)))
+                throw new Error("Invalid entry ID");
+            value = await options.agent.harness.commit((tx) => tx.entry(Number(id)), BACKGROUND_CONTEXT);
+            if (!value) {
+                await json(response, 404, { error: "Entry not found" });
+                return;
+            }
+        }
         else if (url.pathname === "/tasks/task/data") {
             const id = url.searchParams.get("taskId");
             if (!id || !/^\d+$/.test(id) || !Number.isSafeInteger(Number(id)))
@@ -265,7 +310,7 @@ export async function startWeb(options) {
             value = await settings();
         else if (page === "/logs") {
             const cursor = readCursor(url.searchParams.get("cursor"));
-            const tasks = await options.agent.harness.commit((tx) => tx.scanTasks({}, 100, cursor), BACKGROUND_CONTEXT);
+            const tasks = await options.agent.harness.commit((tx) => tx.scanTasks(cursor ? {} : { order: "descending" }, 100, cursor), BACKGROUND_CONTEXT);
             let hostLog = "";
             try {
                 const file = await open(join(options.workingDir, "service.log"), "r");

package/dist/web/style.css

@@ -439,6 +439,12 @@ body.page-logs .native-state {
 	padding: 8px 0 8px 16px;
 }
 
+/* Entries are history records, not work: all grey, no marker of their own. */
+.task-tree li.entry > details > summary {
+	opacity: 0.6;
+	list-style: none;
+}
+
 .schedule-row {
 	background: var(--surface);
 	margin-bottom: 6px;
@@ -541,3 +547,37 @@ body.page-logs .native-state {
 		width: 100px;
 	}
 }
+
+.chat-table th,
+.chat-table td {
+	padding: 8px 16px;
+	border-bottom: 1px solid var(--border);
+}
+
+.chat-table th {
+	opacity: 0.55;
+	white-space: nowrap;
+}
+
+.chat-table td:first-child {
+	width: 100%;
+	word-break: break-all;
+}
+
+.chat-table tbody tr:last-child td {
+	border-bottom: 0;
+}
+
+.chat-silent {
+	opacity: 0.55;
+}
+
+.chat-empty {
+	padding: 12px 16px;
+}
+
+/* The Chats tables grow with their rows; the page itself scrolls. */
+body.page-chats .card {
+	max-height: none;
+	overflow: visible;
+}

package/dist/web/tasks.js

@@ -1,63 +1,205 @@
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { UserEntry, } from "@earendil-works/pi-durable";
 import { displayHistory, historyActivity } from "./history.js";
-/** Read one consistent tree, including terminal receipts and task-owned conversations. */
+/** Newest generations shown per conversation, with every entry and task from the turn of the oldest one. */
+export const RECENT_GENERATIONS_PER_CONVERSATION = 10;
+/** Newest tasks shown for a conversation that never generated (schedulers). */
+export const RECENT_TASKS_PER_CONVERSATION = 20;
+/** Pages of 5 entries read back from the oldest generation to find the user message that opened its turn. */
+const TURN_LOOKBACK_PAGES = 4;
+function firstLine(text, limit = 80) {
+    return text
+        .replace(/^\[(?:Group '[^']*'|DM|SMS) from [^\]]+\] /, "")
+        .split("\n")
+        .find((line) => line.trim())
+        ?.trim()
+        .slice(0, limit);
+}
+/** One line per entry: the first user or assistant message, tool calls by name only, tool results by text. */
+function summarizeEntry(entry) {
+    const message = entry.model?.[0];
+    if (!message)
+        return { role: undefined, text: undefined };
+    const content = message.content;
+    const text = typeof content === "string"
+        ? content
+        : content
+            .map((block) => block.type === "text"
+            ? block.text
+            : block.type === "toolCall"
+                ? `[toolCall ${block.name}]`
+                : block.type === "thinking"
+                    ? "[thinking]"
+                    : `[${block.type}]`)
+            .filter(Boolean)
+            .join(" ");
+    return { role: message.role, text: firstLine(text) };
+}
+/**
+ * Read one consistent tree, newest first: all conversations, every unfinished task, every task that owns a
+ * conversation and their parent chains. Per conversation the window is the newest generations plus every
+ * entry and task back to the `pi.user` entry that opened the oldest one's turn. Entries and tasks share one
+ * id sequence, so the window is a plain id range and the browser nests records by `owner` and `byTaskId`
+ * without any inference. Descending scans stop at the window instead of reading the whole history
+ * (earendil-works/pi#10546).
+ */
 export function readTaskTree(harness) {
     return harness.commit(async (tx) => {
         const conversations = [];
+        const kept = new Map();
+        const entries = [];
+        const more = {};
         let cursor;
         do {
             const page = await tx.scanConversations({}, 100, cursor);
             for (const conversation of page.items) {
-                const history = await tx.scanEntries({ conversationId: conversation.id }, 100);
-                const { groupName } = displayHistory(history, 1);
+                const id = conversation.id;
+                // One descending scan: the newest tasks down to the oldest shown generation; a task scan with a
+                // conversation filter walks the global task order, so it must not run twice per conversation.
+                const recent = [];
+                let oldest;
+                let generations = 0;
+                let next;
+                scan: do {
+                    const tasks = await tx.scanTasks({ conversationId: id, order: "descending" }, 100, next);
+                    for (const task of tasks.items) {
+                        if (task.kind === "pi.generation") {
+                            if (++generations > RECENT_GENERATIONS_PER_CONVERSATION) {
+                                more[id] = true;
+                                break scan;
+                            }
+                            oldest = task;
+                        }
+                        else if (!generations && recent.length >= RECENT_TASKS_PER_CONVERSATION) {
+                            more[id] = true;
+                            break scan;
+                        }
+                        recent.push(task);
+                    }
+                    next = tasks.next;
+                } while (next);
+                let history;
+                let floor;
+                if (oldest) {
+                    history = [];
+                    let next;
+                    do {
+                        const window = await tx.scanEntries({ conversationId: id, minEntryId: oldest.id }, 100, next);
+                        history.push(...window.items);
+                        next = window.next;
+                    } while (next);
+                    // Walk back to the user message that opened the oldest generation's turn.
+                    let max = oldest.id - 1;
+                    for (let pages = 0; pages < TURN_LOOKBACK_PAGES; pages++) {
+                        const older = await tx.scanEntries({ conversationId: id, maxEntryId: max }, 5);
+                        const user = older.items.findIndex((entry) => UserEntry.is(entry));
+                        history.push(...(user === -1 ? older.items : older.items.slice(0, user + 1)));
+                        if (user !== -1 || !older.items.length)
+                            break;
+                        max = older.items[older.items.length - 1].id - 1;
+                    }
+                    const turn = history.find((entry) => UserEntry.is(entry) && entry.id < oldest.id);
+                    floor = turn ? turn.id : oldest.id;
+                    history = history.filter((entry) => entry.id >= floor);
+                    // Tasks between the turn's user message and its first generation sit on the next page.
+                    while (next && (recent.at(-1)?.id ?? 0) >= floor) {
+                        const tasks = await tx.scanTasks({ conversationId: id, order: "descending" }, 100, next);
+                        recent.push(...tasks.items.filter((task) => task.id >= floor));
+                        next = tasks.next;
+                    }
+                }
+                else {
+                    // Names and activity still come from the newest 100 entries, as on the Messages page.
+                    history = [...(await tx.scanEntries({ conversationId: id }, 100)).items];
+                    floor = history[RECENT_TASKS_PER_CONVERSATION - 1]?.id ?? 0;
+                }
+                const page = { items: history, next: undefined };
+                const { groupName } = displayHistory(page, 1);
                 conversations.push({
                     ...conversation,
-                    updatedAt: historyActivity(history),
+                    updatedAt: historyActivity(page),
                     groupName: typeof groupName === "string" ? groupName : undefined,
                 });
+                for (const entry of history) {
+                    if (entry.id < floor)
+                        continue;
+                    entries.push({
+                        id: entry.id,
+                        conversationId: id,
+                        kind: entry.kind,
+                        byTaskId: entry.byTaskId,
+                        ...summarizeEntry(entry),
+                    });
+                }
+                for (const task of recent)
+                    if (!oldest || task.id >= floor)
+                        kept.set(task.id, task);
+                if (conversation.owner && !kept.has(conversation.owner.taskId)) {
+                    const owner = await tx.task(conversation.owner.taskId);
+                    if (owner)
+                        kept.set(owner.id, owner);
+                }
             }
             cursor = page.next;
         } while (cursor);
-        const tasks = [];
+        // Unfinished tasks can be old (sleeping schedulers); status scans are small.
+        for (const status of ["pending", "running", "waiting", "sleeping"]) {
+            cursor = undefined;
+            do {
+                const page = await tx.scanTasks({ status, order: "descending" }, 100, cursor);
+                for (const task of page.items)
+                    kept.set(task.id, task);
+                cursor = page.next;
+            } while (cursor);
+        }
+        // A kept child needs its parent chain so the tree can place it.
+        for (const task of [...kept.values()]) {
+            for (let owner = task.owner; owner !== undefined && !kept.has(owner); owner = kept.get(owner)?.owner) {
+                const parent = await tx.task(owner);
+                if (!parent)
+                    break;
+                kept.set(parent.id, parent);
+            }
+        }
         const assistants = new Map();
-        do {
-            const page = await tx.scanTasks({}, 100, cursor);
-            for (const task of page.items) {
-                let name;
-                const input = task.input;
-                if (task.kind === "pi.tool" && input && typeof input === "object" && !Array.isArray(input)) {
-                    if (typeof input.assistant === "number" && typeof input.callId === "string") {
-                        const id = input.assistant;
-                        if (!assistants.has(id))
-                            assistants.set(id, await tx.entry(id));
-                        for (const message of assistants.get(id)?.model ?? []) {
-                            if (message.role !== "assistant")
-                                continue;
-                            const call = message.content.find((block) => block.type === "toolCall" && block.id === input.callId);
-                            if (call?.type === "toolCall")
-                                name = call.name;
-                        }
+        const tasks = [];
+        for (const task of [...kept.values()].sort((a, b) => Number(b.id) - Number(a.id))) {
+            let name;
+            const input = task.input;
+            if (task.kind === "pi.tool" && input && typeof input === "object" && !Array.isArray(input)) {
+                const call = input;
+                if (typeof call.assistant === "number" && typeof call.callId === "string") {
+                    const id = call.assistant;
+                    if (!assistants.has(id))
+                        assistants.set(id, await tx.entry(id));
+                    for (const message of assistants.get(id)?.model ?? []) {
+                        if (message.role !== "assistant")
+                            continue;
+                        const block = message.content.find((item) => item.type === "toolCall" && item.id === call.callId);
+                        if (block?.type === "toolCall")
+                            name = block.name;
                     }
                 }
-                const state = task.state;
-                tasks.push({
-                    id: task.id,
-                    conversationId: task.conversationId,
-                    owner: task.owner,
-                    kind: task.kind,
-                    name,
-                    background: task.background,
-                    abortRequested: task.abortRequested,
-                    status: state.status,
-                    phase: state.checkpoint && typeof state.checkpoint === "object" && !Array.isArray(state.checkpoint)
-                        ? state.checkpoint.phase
-                        : undefined,
-                    on: state.status === "waiting" ? state.on : undefined,
-                    outcome: state.outcome?.status,
-                });
             }
-            cursor = page.next;
-        } while (cursor);
-        return { conversations, tasks };
+            const state = task.state;
+            tasks.push({
+                id: task.id,
+                conversationId: task.conversationId,
+                owner: task.owner,
+                kind: task.kind,
+                name,
+                background: task.background,
+                abortRequested: task.abortRequested,
+                status: state.status,
+                // Phases exist only while a task runs; a terminal record keeps its outcome and drops the checkpoint.
+                phase: state.checkpoint && typeof state.checkpoint === "object" && !Array.isArray(state.checkpoint)
+                    ? state.checkpoint.phase
+                    : undefined,
+                on: state.status === "waiting" ? state.on : undefined,
+                until: state.status === "sleeping" ? state.until : undefined,
+                outcome: state.outcome?.status,
+            });
+        }
+        return { conversations, tasks, entries, more };
     }, BACKGROUND_CONTEXT);
 }

package/docs/adr/0048-quiet-attachment-reads.md

@@ -0,0 +1,11 @@
+# 0048. Quiet attachment reads
+
+Status: proposed (owner-requested behavior in #38, 2026-10-07)
+
+**Problem.** Reading an archived attachment adds noisy tool notices containing long private archive paths.
+
+**Example.** A native `read` of `WORKING_DIR/attachments/<chat>/<file>` produces no request or completion notice. An ordinary file read still shows the existing progress pair.
+
+**Decision.** Add a narrow exception to ADR 0040's all-tool progress rule: suppress both admission and settlement notices for native `read` calls under the active workspace attachment root, including owned child calls and failed reads. Normalize relative, home, @ and file-URL paths and resolve filesystem aliases using metadata only. Match directory boundaries, not a generic attachment substring. Other reads, tools, task progress, manual compaction and final replies remain unchanged.
+
+The existing native observer filters before assigning notice routing or making direct-send receipts. Execution, result/error history, receipt/no-replay rules and the single pipeline are unchanged. No new poller, sender, permission boundary, data removal or credential policy is introduced.

package/docs/adr/0049-per-chat-progress-notices.md

@@ -0,0 +1,21 @@
+# 0049. Per-chat progress notices
+
+Status: proposed (owner-requested implementation, 2026-10-24)
+
+**Problem.** `progressMessages` in `settings.json` turns tool progress notices on or off for every chat at once. A busy group wants only the final messages while an admin chat wants to watch the tools.
+
+**Example.**
+
+```text
+/verbose            -> Verbose: on (default)
+/verbose off        -> Verbose: off (this chat only)
+/verbose default    -> Verbose: on (default)
+```
+
+**Decision.**
+
+- Each chat record in the native `imessage.chats` document gets an optional `progress` boolean. `/verbose on|off` sets it and `/verbose default` removes it; `/verbose` alone reports the effective state. The record version is unchanged; old records have no field.
+- The progress observer (ADR 0040) resolves the owning chat first and then gates both the admission and the settlement notice by `chat.progress ?? settings.progressMessages`. Reply-enabled allowlisting, formatting, screening, receipts and no-replay rules are unchanged.
+- `settings.json` stays the default and is never rewritten by a command; the per-chat choice lives only in Durable.
+
+**Consequences.** A `/verbose off` chat still runs tools and records their results; it only stops seeing the two notice lines. Child notices follow the owning chat's choice. Changing the global default does not touch chats with an explicit choice.

package/docs/adr/0052-host-owned-self-restart.md

@@ -0,0 +1,53 @@
+# 0052. The host owns its own restart
+
+Status: accepted (owner accepted on 2026-10-24)
+
+**Problem.** A chat assistant restarts the service by writing a controller
+script and running it from a `bash` tool call. The host cannot tell that this
+call is about to stop it. When the call is still running at the stop, ADR 0041
+reruns it on the next start, which launches another controller and stops the
+service again (#39: about 70 restarts in eleven minutes). A host-side stop
+heuristic that aborts a tool interrupted twice in a row was tried the same
+day; it limits the damage after the fact, does not remove the cause, and
+aborts any long tool that two deployments happen to interrupt in a row.
+
+**Example.**
+
+```text
+restart_service({ release: "d627232…" })
+-> Restart into /Users/clawbot/pi-imessage-releases/d627232… is scheduled;
+   the service stops after this call settles. Controller directory:
+   /tmp/pi-imessage-restart.Xy12ab. Verify in a later call.
+```
+
+The call settles, the host opens the controller in Terminal, the controller
+stops the old process and becomes the new one. The next turn verifies the
+listener, the log and the running release directory.
+
+**Decision.**
+
+- A built-in `restart_service` tool takes the full commit hash of a prepared
+  release directory, a sibling of the running one. It refuses a hash that is not
+  a directory with `src/cli.ts`, `node_modules` and `ops/restart.command`, and
+  a second request while one is scheduled.
+- The tool writes the private controller directory of ops/README.md step 3
+  itself: `environment.sh` from the process environment, `control.sh` from the
+  process's own PID, start time and command line, and a copy of
+  `ops/restart.command` from the target release. The controller deletes
+  `environment.sh` after sourcing it.
+- The tool returns at once. The host launches the controller only after the
+  tool task has settled, so the stop can never interrupt the call that asked
+  for it.
+- The tool is `replay: "unsafe"`. If it is interrupted anyway, the model gets
+  an interrupted result and checks what is running instead of a rerun
+  launching a second controller.
+- Ordinary tools keep the rerun default of ADR 0041. Operators keep the manual
+  procedure for a cold start when no service is running.
+
+**Consequences.** A self-restart costs one restart and no extra model turn.
+The stop still happens at a tool boundary of the requesting chat, so that chat's
+next model request is repeated after the restart, as ADR 0041 accepts. The
+restart loop of #39 cannot recur through this tool, so the stop heuristic is
+removed and ADR 0041 applies unchanged to every other tool. A chat that writes
+its own controller through `bash` is still subject to the ops rule of ending
+the call right after `open`.

package/docs/adr/0053-service-log-errors.md

@@ -0,0 +1,44 @@
+# 0053. Service-log errors for failures that break normal operation
+
+Status: proposed
+
+**Problem.** Durable records every task outcome, but only in its storage.
+`service.log` shows startup, sends and a few delivery warnings. On 2026-10-25
+the nightly memory reflection failed three times because the model child had
+exhausted a provider quota; the process, the port and the root HTTP check
+looked healthy and `service.log` had no line about it. The failure was only
+visible by reading `durable/main.jsonl` or by a chat notice that was deduped.
+
+**Example.**
+
+```text
+2026-10-25T00:14:48.924Z Model call failed {
+  kind: 'pi.generation', task: 183434, conversation: 183426, status: 'failed',
+  provider: 'openai-codex', model: 'gpt-6.1-sol',
+  reason: 'You have hit your ChatGPT usage limit (plus plan). Try again in ~291 min.'
+}
+```
+
+**Decision.**
+
+- `service.log` gets a `console.error` line with an ISO timestamp for a failure
+  that breaks normal operation. A failure qualifies when either holds: a chat
+  or scheduled job does not get the result it was waiting for, or the system
+  enters a state that needs an operator. Transient errors that recover on
+  their own, such as a retried provider error or a delivery whose status is
+  later confirmed, do not qualify.
+- One module, `src/agent/error-log.ts`, owns these lines. It observes Durable
+  commits synchronously and never calls Session APIs. Each error kind is one
+  branch with its own message name; adding a kind states which of the two
+  conditions it meets.
+- The first kind is a model call that ends `failed` or `faulted`: the line
+  carries the task, conversation, provider, model and the reason truncated to
+  200 characters. It carries no prompt, tool argument or input content.
+- Other task kinds, including scheduled jobs that fault, are not logged yet;
+  they are added under the same conditions when needed.
+
+**Consequences.** A quota, auth or provider outage is visible in the service
+log within the same commit that records it, so a health check that reads the
+log catches it without a paid model probe. The web `/logs` page shows the same
+lines. Durable records remain the full source of truth; the log is a pointer
+to them, not a replacement.

package/docs/adr/README.md

@@ -23,7 +23,7 @@ Accepted ADR files are never edited; this index records which ones are current.
 | [0018](0018-tasks-without-prompt-api.md) | Ordinary `/stop`; no HTTP `/prompt` or `/send` | Active |
 | [0036](0036-workspace-policy-and-neutral-service-id.md) | Workspace policy and neutral service ID | Active |
 | [0040](0040-chat-progress-notices.md) | Chat progress notices | Active; consolidates 0020–0028, 0031 |
-| [0041](0041-restart-and-recovery.md) | Restart and recovery | Active; consolidates 0037–0039 |
+| [0041](0041-restart-and-recovery.md) | Restart and recovery | Active; consolidates 0037–0039; self-restart path added by 0052 |
 | [0042](0042-background-schedules-and-workspace-extensions.md) | Background schedules and workspace extensions | Active; operator-run clause replaced by 0047 |
 | [0043](0043-remove-legacy-migration.md) | Remove the legacy migration code | Active; archived at tag `archive/legacy-migration` |
 | [0044](0044-message-channels.md) | Organize message sources as channels | Proposed |
@@ -31,6 +31,10 @@ Accepted ADR files are never edited; this index records which ones are current.
 
 | [0046](0046-selective-command-redaction.md) | Selective command-preview redaction | Proposed; owner-requested implementation in #36 |
 | [0047](0047-one-scheduling-path.md) | One scheduling path for recurring and one-off work | Active |
+| [0048](0048-quiet-attachment-reads.md) | Quiet attachment reads | Proposed; owner-requested implementation in #38 |
+| [0049](0049-per-chat-progress-notices.md) | Per-chat progress notices via `/verbose` | Proposed; owner-requested implementation |
+| [0052](0052-host-owned-self-restart.md) | The host owns its own restart (`restart_service`) | Active; owner accepted on 2026-10-24 (#39) |
+| [0053](0053-service-log-errors.md) | Service-log errors for failures that break normal operation | Proposed; first kind (model call failed) implemented |
 
 ## Replaced or rejected
 
@@ -47,4 +51,5 @@ Accepted ADR files are never edited; this index records which ones are current.
 | [0032](0032-native-background-schedules.md)–[0035](0035-external-business-task-extensions.md) | Native schedules, operator run, local time, workspace extensions | 0042 |
 | [0037](0037-restart-during-in-flight-work.md)–[0039](0039-rerun-interrupted-tools.md) | Restart and tool rerun | 0041 |
 
-Number 0029 was never used.
+Numbers 0029, 0050 and 0051 are not used: 0050 and 0051 were interim stop
+heuristics for #39 that the owner did not accept; 0052 replaced them.

package/docs/api.md

@@ -5,17 +5,27 @@
 Default address: `http://localhost:7750` (configured by `WEB_HOST` and `WEB_PORT`).
 The server has no authentication; do not expose it to untrusted networks.
 
-The pages `/`, `/chat`, `/tasks`, `/scheduled`, `/settings`, `/memory` and `/logs` are read-only.
+The pages `/`, `/chat`, `/chats`, `/tasks`, `/scheduled`, `/settings`, `/memory` and `/logs` are read-only.
+The Chats tab (`/chats`, `/chats/data`) lists groups and direct chats, one row
+each: reply eligibility, the `/verbose` choice with its effective value, the
+conversation's model and thinking level, and last activity. Chats that do not
+reply are dimmed. It never shows message text. The message history page in the
+navigation is labelled Messages.
 The Tasks tab shows real chat and native schedule ownership trees, including
 subagent child conversations and terminal tasks. Internal-only conversations such as model-health
 are hidden, including when selected by URL; their stored data is not deleted.
 `/tasks/data` retains all conversation records for native diagnostics
-and lightweight task summaries, reading every native scan page. Input and payloads
+and lightweight task summaries, newest first. It lists every unfinished task,
+every task that owns a conversation, their parent chains and the 20 newest
+tasks per conversation, read with descending scans so the full task history is
+not scanned; a conversation with older tasks is flagged in `more` and shows one
+line. The Scheduled history and the Logs task list use the same descending
+order, so "Older tasks" pages go back in time. Input and payloads
 are fetched only when a task is expanded, through `/tasks/task/data?taskId=ID`.
 `/tasks?conversationId=ID` focuses one conversation and its descendants. The tree
 and expanded tasks update only on manual refresh. Conversation lists and sidebars
 use newest message activity first, with conversation ID as a descending tie-break;
-Tasks uses the same activity clock as Recent Chats, not conversation creation order.
+Tasks uses the same activity clock as Messages, not conversation creation order.
 Conversation windows have a maximum height of `min(560px, 70dvh)` and scroll inside. These are latest task states,
 not checkpoint history: terminal tasks retain input and outcome, but no checkpoint.
 Existing redaction and large-string truncation apply to task details too.
@@ -89,4 +99,6 @@ previews. Raw outputs, commands, prompts and document contents stay local.
 Known credential indicators are redacted; arbitrary user-authored secrets cannot
 be guaranteed detectable. Missing or false keeps final-only delivery. The setting
 is reread for each notice; old tasks and unknown sends are not replayed
-([ADR 0020](adr/0020-chat-task-progress.md)).
+([ADR 0040](adr/0040-chat-progress-notices.md)). `/verbose on|off` in a chat
+overrides this default for that chat only and `/verbose default` removes the
+override ([ADR 0049](adr/0049-per-chat-progress-notices.md)).