@kingcrab/pi-imessage 1.0.0 → 1.1.1

package/dist/extensions/restart.js

@@ -0,0 +1,100 @@
+import { execFile } from "node:child_process";
+import { access, chmod, copyFile, mkdtemp, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+import { Type } from "@earendil-works/pi-ai";
+import { defineExtension, defineTool } from "@earendil-works/pi-durable";
+const execFileAsync = promisify(execFile);
+/** Variables that describe the old shell session or that the controller sets itself. */
+const EXCLUDED_ENVIRONMENT = new Set(["_", "PWD", "OLDPWD", "SHLVL", "TERM_SESSION_ID"]);
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+async function processField(field) {
+    const { stdout } = await execFileAsync("ps", ["-p", String(process.pid), "-o", `${field}=`]);
+    // Exactly what the controller's `$(ps ...)` yields: trailing newlines stripped, nothing else.
+    return stdout.replace(/\n+$/, "");
+}
+/** Writes the private controller directory of ops/README.md step 3 for the target release; starts nothing. */
+export async function prepareRestart(options, release) {
+    if (!/^[0-9a-f]{40}$/.test(release))
+        throw new Error("release must be the full commit hash of a prepared release directory");
+    const target = join(dirname(options.currentRelease), release);
+    for (const entry of ["src/cli.ts", "node_modules", "ops/restart.command"]) {
+        await access(join(target, entry)).catch(() => {
+            throw new Error(`Release directory is not prepared: ${join(target, entry)} is missing`);
+        });
+    }
+    const [started, command] = await Promise.all([processField("lstart"), processField("command")]);
+    const deployDir = await mkdtemp(join(options.deployRoot, "pi-imessage-restart."));
+    // The whole process environment, including .env values loaded at startup; the controller deletes the file.
+    const environment = Object.entries(process.env)
+        .filter(([name, value]) => value !== undefined && /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) && !EXCLUDED_ENVIRONMENT.has(name))
+        .map(([name, value]) => `export ${name}=${shellQuote(value ?? "")}`);
+    await writeFile(join(deployDir, "environment.sh"), `${environment.join("\n")}\n`, { mode: 0o600 });
+    const control = {
+        OLD_PID: String(process.pid),
+        OLD_STARTED: started,
+        EXPECTED_COMMAND: command,
+        REPO: target,
+        NODE: process.execPath,
+        WORKING_DIR: options.workingDir,
+        WEB_PORT: process.env.WEB_PORT ?? "7750",
+        LOG_FILE: join(options.workingDir, "service.log"),
+    };
+    await writeFile(join(deployDir, "control.sh"), `${Object.entries(control)
+        .map(([name, value]) => `${name}=${shellQuote(value)}`)
+        .join("\n")}\n`, { mode: 0o600 });
+    const controller = join(deployDir, "restart.command");
+    await copyFile(join(target, "ops", "restart.command"), controller);
+    await chmod(controller, 0o700);
+    return { target, deployDir, controller };
+}
+/** The claw baseline: a Terminal window keeps the controller alive independently of this process. */
+export async function launchInTerminal(controller) {
+    await execFileAsync("open", ["-a", "Terminal", controller], { timeout: 15_000 });
+}
+/** The chat assistant restarts the service through the host instead of a bash command that stops its own host. */
+export function restartExtension(options) {
+    let scheduled;
+    return defineExtension({
+        name: "restart",
+        tools: [
+            defineTool({
+                name: "restart_service",
+                description: "Restart this service into a prepared release directory: a sibling of the running one named by its full commit hash, with npm ci and ops/preflight.mjs done. The service stops only after this call has settled; end the call at once and verify in a later call: controller.log and new.pid in the returned directory, then the service log, the listener and the running release directory. Never call it again before the first outcome is known.",
+                parameters: Type.Object({
+                    release: Type.String({ description: "Full commit hash of the prepared release directory" }),
+                }),
+                // A rerun would launch a second controller (#39); an interrupted call is reported to the model instead.
+                replay: "unsafe",
+                async execute(args, api) {
+                    if (scheduled)
+                        throw new Error(`A restart is already scheduled from ${scheduled}`);
+                    const prepared = await prepareRestart(options, args.release);
+                    scheduled = prepared.deployDir;
+                    console.log(new Date().toISOString(), "Restart requested", {
+                        release: args.release,
+                        controller: prepared.deployDir,
+                        task: api.taskId,
+                    });
+                    void options
+                        .settled(api.taskId)
+                        .then(() => options.launch(prepared.controller))
+                        .catch((error) => {
+                        scheduled = undefined;
+                        console.error(new Date().toISOString(), "Restart launch failed", error);
+                    });
+                    return {
+                        output: [
+                            {
+                                type: "text",
+                                text: `Restart into ${prepared.target} is scheduled; the service stops after this call settles. Controller directory: ${prepared.deployDir}. Verify in a later call.`,
+                            },
+                        ],
+                    };
+                },
+            }),
+        ],
+    });
+}

package/dist/extensions/schedules.js

@@ -5,6 +5,7 @@ export const ScheduledOutbox = defineDoc({
     version: 1,
     scope: "session",
     initial: () => ({ items: [] }),
+    checkpointWhen: () => false,
 });
 export function validateSchedules(extensions) {
     const ids = new Set(["compact-chats"]);

package/dist/extensions/subagent.js

@@ -41,7 +41,7 @@ export const Subagent = defineExtension({
                 const answer = await api.commit((tx) => tx.entry(result.answer), context);
                 const message = answer?.model?.[0];
                 return {
-                    content: [
+                    output: [
                         {
                             type: "text",
                             text: finalReplyText(message) ?? "",

package/dist/extensions/web.js

@@ -9,6 +9,7 @@ export const WebResults = defineDoc({
     history: "rewindable",
     fork: "asOf",
     initial: () => ({ queries: {} }),
+    checkpointWhen: () => false,
 });
 async function fetchBounded(url, options = {}) {
     const parsed = new URL(url);
@@ -65,7 +66,7 @@ export function webExtension(apiKey = process.env.BRAVE_API_KEY ?? process.env.B
                         for (const key of keys.slice(0, Math.max(0, keys.length - 20)))
                             delete results.queries[key];
                     }, context);
-                    return { content: [{ type: "text", text }] };
+                    return { output: [{ type: "text", text }] };
                 },
             }),
             defineTool({
@@ -81,7 +82,7 @@ export function webExtension(apiKey = process.env.BRAVE_API_KEY ?? process.env.B
                             ? (await Defuddle(result.bytes.toString(), result.url, { markdown: true, useAsync: false }))
                                 .content
                             : result.bytes.toString();
-                    return { content: [{ type: "text", text: text.slice(0, 50000) }] };
+                    return { output: [{ type: "text", text: text.slice(0, 50000) }] };
                 },
             }),
             defineTool({
@@ -91,7 +92,7 @@ export function webExtension(apiKey = process.env.BRAVE_API_KEY ?? process.env.B
                 replay: "safe",
                 async execute(args, api, context) {
                     const data = await api.snapshot(WebResults, api.conversationId, context);
-                    return { content: [{ type: "text", text: data?.queries[args.query] ?? "No saved result" }] };
+                    return { output: [{ type: "text", text: data?.queries[args.query] ?? "No saved result" }] };
                 },
             }),
         ],

package/dist/extensions/workspace.js

@@ -16,7 +16,7 @@ export function workspaceExtension(reload) {
                 parameters: Type.Object({}),
                 async execute() {
                     await reload();
-                    return { content: [{ type: "text", text: "Workspace extensions and configuration reloaded." }] };
+                    return { output: [{ type: "text", text: "Workspace extensions and configuration reloaded." }] };
                 },
             }),
         ],

package/dist/main.js

@@ -7,6 +7,7 @@ import { compactionReply, isCommand, runCommand } from "./agent/commands.js";
 import { compactChats } from "./agent/compaction.js";
 import { deliverReplies, recoverSending } from "./agent/deliver.js";
 import { deliverDirect } from "./agent/direct-send.js";
+import { logErrors } from "./agent/error-log.js";
 import { openHarness } from "./agent/harness.js";
 import { submitHealth } from "./agent/health.js";
 import { openModels, readDefaults, requestSettings, withModelPolicy } from "./agent/models.js";
@@ -19,6 +20,7 @@ import { createBrowser } from "./extensions/browser.js";
 import { memoryExtension } from "./extensions/memory.js";
 import { messageExtension } from "./extensions/message.js";
 import { ImageRead } from "./extensions/read-image.js";
+import { launchInTerminal, restartExtension } from "./extensions/restart.js";
 import { validateSchedules } from "./extensions/schedules.js";
 import { Subagent } from "./extensions/subagent.js";
 import { webExtension } from "./extensions/web.js";
@@ -75,6 +77,14 @@ reloadHttpTransport) {
                     browser.extension,
                     Subagent,
                     workspaceExtension(reload),
+                    // ADR 0052: the service runs from a release directory; the controller starts after the call settles.
+                    restartExtension({
+                        workingDir: options.workingDir,
+                        currentRelease: process.cwd(),
+                        deployRoot: "/tmp",
+                        settled: (taskId) => harness.waitForTask(taskId, BACKGROUND_CONTEXT),
+                        launch: launchInTerminal,
+                    }),
                 ]),
             ...(await loadWorkspaceExtensions(options.workingDir)),
         ];
@@ -96,6 +106,7 @@ reloadHttpTransport) {
     const { harness, storage } = owner;
     const scheduling = schedulingExtension(harness, defaults);
     let progress;
+    const stopErrorLog = logErrors(harness);
     try {
         // The native owner lock is acquired before cleaning up browsers left by a previous process.
         await browser.close();
@@ -271,6 +282,7 @@ reloadHttpTransport) {
                     models: runtime.models,
                     defaults,
                     reload,
+                    workingDir: options.workingDir,
                     chatGuid: snapshot.chatGuid,
                     guid: snapshot.guid,
                     text: snapshot.text,
@@ -384,6 +396,7 @@ reloadHttpTransport) {
             closing ??= (async () => {
                 await Promise.allSettled([...operations]);
                 await progress.close();
+                stopErrorLog();
                 await owner.close(browser.close);
             })();
             return closing;
@@ -436,10 +449,15 @@ export async function startMessaging(options, reloadHttpTransport) {
     let closing;
     let timer;
     let started = false;
+    /** Rows committed before the call are read even when a poll is already in flight. */
     function poll() {
         if (closed)
             return Promise.reject(new Error("Messaging is closed"));
-        pending ??= (async () => {
+        const previous = pending?.catch(() => undefined) ?? Promise.resolve();
+        const current = previous
+            .then(async () => {
+            if (closed)
+                return;
             try {
                 await watcher.poll();
             }
@@ -448,10 +466,13 @@ export async function startMessaging(options, reloadHttpTransport) {
                 if (!closed)
                     await service.deliver();
             }
-        })().finally(() => {
-            pending = undefined;
+        })
+            .finally(() => {
+            if (pending === current)
+                pending = undefined;
         });
-        return pending;
+        pending = current;
+        return current;
     }
     function tick() {
         void poll()

package/dist/web/app.js

@@ -16,7 +16,8 @@ document.body.classList.add(`page-${page.slice(1)}`);
 if (conversationId) document.body.classList.add("conversation-detail");
 document.getElementById("title").textContent =
 	{
-		"/chat": "Recent Chats",
+		"/chat": "Messages",
+		"/chats": "Chats",
 		"/tasks": "Tasks",
 		"/scheduled": "Scheduled tasks",
 		"/logs": "Logs",
@@ -424,6 +425,80 @@ function renderSettings() {
 	}
 }
 
+function renderChatSettings() {
+	const chats = data.chats || [];
+	const overrides = chats.filter((chat) => chat.verbose.chat !== undefined).length;
+	view.replaceChildren(
+		element(
+			"p",
+			[
+				`${chats.length} chats`,
+				`default verbose ${data.defaults?.progressMessages ? "on" : "off"}`,
+				`${overrides} ${overrides === 1 ? "override" : "overrides"}`,
+				"read-only: /verbose and /thinking change a chat, settings.json the default",
+			].join(" · "),
+			"muted",
+		),
+	);
+	// A main value with its source or provider underneath keeps each column scannable.
+	function stacked(main, detail) {
+		const cell = element("td", undefined, "c-fix");
+		cell.append(element("div", main));
+		if (detail) cell.append(element("div", detail, "meta"));
+		return cell;
+	}
+	function section(id, title, rows) {
+		const card = element("section", undefined, "card");
+		card.id = `chats-${id}`;
+		const header = element("header", undefined, "card-header");
+		header.append(element("span", title), element("span", String(rows.length), "meta"));
+		card.append(header);
+		const table = element("table", undefined, "chat-table");
+		const heading = table.createTHead().insertRow();
+		for (const label of ["Chat", "Replies", "Verbose", "Model", "Thinking", "Last activity"])
+			heading.append(element("th", label));
+		const body = table.createTBody();
+		for (const chat of rows) {
+			const row = body.insertRow();
+			if (!chat.replies) row.className = "chat-silent";
+			const name = row.insertCell();
+			// Group name, or the handle of a direct chat; the raw GUID stays in the native state only.
+			const handle = chat.chatGuid.includes(";+;") ? "unnamed group" : chat.chatGuid.split(";").at(-1);
+			name.append(link(chat.groupName || handle, `/chat?conversationId=${chat.conversationId}`));
+			const [provider, ...modelId] = (chat.model || "").split("/");
+			const activity =
+				typeof chat.updatedAt === "number"
+					? new Date(chat.updatedAt).toLocaleString("sv-SE").slice(0, 16)
+					: "";
+			row.append(
+				stacked(chat.replies ? "on" : "off"),
+				stacked(
+					chat.verbose.effective ? "on" : "off",
+					chat.verbose.chat === undefined ? "default" : "this chat",
+				),
+				stacked(modelId.join("/") || "-", chat.model ? provider : undefined),
+				stacked(chat.thinking || "-"),
+				stacked(activity || "-"),
+			);
+		}
+		card.append(table);
+		if (!rows.length) card.append(element("p", "None.", "empty chat-empty"));
+		return card;
+	}
+	view.append(
+		section(
+			"groups",
+			"Groups",
+			chats.filter((chat) => chat.chatGuid.includes(";+;")),
+		),
+		section(
+			"direct",
+			"Direct",
+			chats.filter((chat) => !chat.chatGuid.includes(";+;")),
+		),
+	);
+}
+
 function renderLogs() {
 	const scrollPositions = Array.from(view.querySelectorAll(".card-content"), (node) => ({
 		top: node.scrollTop,
@@ -540,7 +615,6 @@ function renderScheduled() {
 
 function renderTasks() {
 	view.replaceChildren();
-	const children = new Map();
 	const conversations = new Map(data.conversations.map((conversation) => [conversation.id, conversation]));
 	const chatNames = new Map(
 		(data.chats?.items || []).map((chat) => [
@@ -548,92 +622,160 @@ function renderTasks() {
 			chatName({ ...chat, history: { groupName: conversations.get(chat.conversationId)?.groupName } }, []),
 		]),
 	);
-	const conversationNames = new Map(chatNames);
 	const scheduleNames = new Map((data.schedules?.items || []).map((job) => [job.conversationId, job.name]));
-	for (const [id, name] of scheduleNames) conversationNames.set(id, name);
-	for (const session of data.sessions?.items || []) {
-		if (!conversationNames.has(session.conversationId))
-			conversationNames.set(session.conversationId, session.label);
-	}
-	function conversationName(id) {
-		const name = conversationNames.get(id);
-		if (name) return name;
+	const sessionNames = new Map(
+		(data.sessions?.items || []).map((session) => [session.conversationId, session.label]),
+	);
+	// Every conversation is named by the session document that created it, or by the task that owns it.
+	function source(id) {
+		if (chatNames.has(id)) return { name: `chat ${chatNames.get(id)}`, doc: "imessage.chats" };
+		if (scheduleNames.has(id))
+			return { name: `schedule ${scheduleNames.get(id)}`, doc: "imessage.schedules" };
+		if (sessionNames.has(id)) return { name: `session ${sessionNames.get(id)}`, doc: "imessage.sessions" };
 		const owner = conversations.get(id)?.owner;
-		if (!owner) return "";
-		const parentName = conversationName(owner.conversationId);
-		return parentName ? `${parentName} / subagent` : "subagent";
+		return owner ? { name: "subagent", doc: "owned by a tool" } : { name: "", doc: "" };
 	}
 	function belongsToChat(id) {
 		if (chatNames.has(id) || scheduleNames.has(id)) return true;
 		const owner = conversations.get(id)?.owner;
 		return owner ? belongsToChat(owner.conversationId) : false;
 	}
-	for (const conversation of data.conversations.toSorted(compareConversations)) {
-		const key = conversation.owner ? `task-${conversation.owner.taskId}` : "root";
+	// Children by storage relation: conversations under their owner task, tasks under their owner task or
+	// conversation, entries under the task that wrote them (byTaskId). A pi.user entry opens a turn: the
+	// later root tasks and loose entries of its conversation nest under it until the next one.
+	const children = new Map();
+	const add = (key, node) => {
 		if (!children.has(key)) children.set(key, []);
-		children.get(key).push({ type: "conversation", ...conversation });
+		children.get(key).push(node);
+	};
+	const taskIds = new Set(data.tasks.map((task) => task.id));
+	for (const conversation of data.conversations) {
+		if (conversation.owner)
+			add(`task-${conversation.owner.taskId}`, { type: "conversation", ...conversation });
+	}
+	const turns = new Map();
+	for (const entry of data.entries || []) {
+		if (entry.kind !== "pi.user") continue;
+		if (!turns.has(entry.conversationId)) turns.set(entry.conversationId, []);
+		turns.get(entry.conversationId).push(entry.id);
+	}
+	// Entries arrive newest first; a turn lookup needs ascending ids.
+	for (const ids of turns.values()) ids.sort((left, right) => left - right);
+	function turnKey(conversationId, id) {
+		const opened = (turns.get(conversationId) || []).filter((turn) => turn < id).at(-1);
+		return opened === undefined ? `conversation-${conversationId}` : `entry-${opened}`;
 	}
 	for (const task of data.tasks) {
-		const key = task.owner === undefined ? `conversation-${task.conversationId}` : `task-${task.owner}`;
-		if (!children.has(key)) children.set(key, []);
-		children.get(key).push({ type: "task", ...task });
+		add(task.owner === undefined ? turnKey(task.conversationId, task.id) : `task-${task.owner}`, {
+			type: "task",
+			...task,
+		});
+	}
+	for (const entry of data.entries || []) {
+		if (entry.kind === "pi.user") add(`conversation-${entry.conversationId}`, { type: "entry", ...entry });
+		else if (entry.byTaskId !== undefined && taskIds.has(entry.byTaskId))
+			add(`task-${entry.byTaskId}`, { type: "entry", ...entry });
+		else add(turnKey(entry.conversationId, entry.id), { type: "entry", ...entry });
+	}
+	// Newest turn first in a card; inside a turn the chain reads in storage order. Cards are sorted by activity.
+	for (const [key, nodes] of children) {
+		if (key.startsWith("conversation-")) nodes.sort((left, right) => right.id - left.id);
+		else nodes.sort((left, right) => left.id - right.id);
+	}
+	function lazyDetails(summary, url) {
+		const detail = element("details");
+		const content = element("pre", "Loading latest state...");
+		detail.append(summary, content);
+		let loaded = false;
+		detail.addEventListener("toggle", async () => {
+			if (!detail.open || loaded) return;
+			loaded = true;
+			try {
+				content.textContent = JSON.stringify(await fetchData(url), null, 2);
+			} catch (error) {
+				loaded = false;
+				content.textContent = error.message;
+			}
+		});
+		return detail;
+	}
+	function taskSummary(node) {
+		const label =
+			node.kind === "pi.generation"
+				? "Generation"
+				: node.kind === "pi.tool"
+					? `Tool ${node.name || "?"}`
+					: node.kind;
+		const summary = element("summary", label);
+		const state = node.outcome ? [node.outcome] : [node.status, node.phase].filter(Boolean);
+		const waiting = node.on?.length ? ` on ${node.on.length} task${node.on.length === 1 ? "" : "s"}` : "";
+		const sleeping =
+			typeof node.until === "number" ? ` until ${new Date(node.until).toLocaleString("sv-SE")}` : "";
+		const flags = `${node.background ? " [background]" : ""}${node.abortRequested ? " [abort requested]" : ""}`;
+		summary.append(element("span", `  [${state.join(" / ")}]${waiting}${sleeping}${flags}`, "meta"));
+		return summary;
+	}
+	function entrySummary(node) {
+		const summary = element("summary", node.kind.replace(/^pi\./, ""));
+		if (node.text) summary.append(element("span", `  "${node.text}"`, "entry-text"));
+		return summary;
 	}
 	function renderNode(node) {
 		const item = element("li");
 		const key = `${node.type}-${node.id}`;
 		item.id = `tree-${key}`;
 		if (node.type === "conversation") {
-			const heading = element("span", `Conversation #${node.id}`);
-			const name = conversationName(node.id);
-			if (name) heading.append(element("span", ` / ${name}  `, "meta"));
-			if (chatNames.has(node.id)) {
-				heading.append(link("Chat", `/chat?conversationId=${node.id}`, "meta"));
-			}
-			item.append(heading);
+			const { name, doc } = source(node.id);
+			// A card is one conversation; a conversation owned by a task folds under it.
+			const heading = element(node.owner ? "summary" : "span", "Conversation");
+			if (name) heading.append(element("span", `  ${name}`));
+			if (doc) heading.append(element("span", `  <- ${doc}`, "meta"));
+			if (chatNames.has(node.id))
+				heading.append(element("span", "  "), link("Chat", `/chat?conversationId=${node.id}`, "meta"));
+			if (node.owner) {
+				const detail = element("details");
+				detail.id = key;
+				detail.append(heading);
+				item.append(detail);
+			} else item.append(heading);
+		} else if (node.type === "task") {
+			const detail = lazyDetails(taskSummary(node), `/tasks/task/data?taskId=${node.id}`);
+			detail.id = key;
+			item.append(detail);
 		} else {
-			const detail = element("details");
+			item.className = node.kind === "pi.user" ? "entry turn" : "entry";
+			const detail = lazyDetails(entrySummary(node), `/tasks/entry/data?entryId=${node.id}`);
 			detail.id = key;
-			const summary = element("summary", `${node.kind}${node.name ? `: ${node.name}` : ""} #${node.id}`);
-			const status = [node.status, node.phase, node.outcome].filter(Boolean).join(" / ");
-			const waiting = node.on?.length ? ` on [${node.on.join(", ")}]` : "";
-			const flags = `${node.background ? " [background]" : ""}${node.abortRequested ? " [abort requested]" : ""}`;
-			summary.append(element("span", `  ${status}${waiting}${flags}`, "meta"));
-			const content = element("pre", "Loading latest state...");
-			detail.append(summary, content);
-			let loaded = false;
-			detail.addEventListener("toggle", async () => {
-				if (!detail.open || loaded) return;
-				loaded = true;
-				try {
-					const task = await fetchData(`/tasks/task/data?taskId=${node.id}`);
-					content.textContent = JSON.stringify(task, null, 2);
-				} catch (error) {
-					loaded = false;
-					content.textContent = error.message;
-				}
-			});
 			item.append(detail);
 		}
 		const descendants = children.get(key) || [];
-		if (descendants.length) {
+		const more = node.type === "conversation" && data.more?.[node.id];
+		if (descendants.length || more) {
 			const list = element("ul", undefined, "task-tree");
 			for (const child of descendants) list.append(renderNode(child));
-			item.append(list);
+			if (more) list.append(element("li", "older turns not listed", "meta"));
+			(node.type === "conversation" && node.owner ? item.firstChild : item).append(list);
 		}
 		return item;
 	}
 	const roots = conversationId
-		? data.conversations
-				.filter((conversation) => String(conversation.id) === conversationId)
-				.map((conversation) => ({ type: "conversation", ...conversation }))
-		: children.get("root") || [];
+		? data.conversations.filter((conversation) => String(conversation.id) === conversationId)
+		: data.conversations.filter((conversation) => !conversation.owner);
 	const visible = roots.filter((conversation) => belongsToChat(conversation.id));
+	if (!conversationId && data.session)
+		view.append(
+			element(
+				"p",
+				`Session ${data.session}  docs: imessage.chats, imessage.schedules, imessage.sessions`,
+				"muted",
+			),
+		);
 	if (!visible.length) view.append(element("p", "No conversations.", "empty"));
 	for (const conversation of visible.toSorted(compareConversations)) {
 		const card = element("section", undefined, "card");
 		card.id = `tasks-${conversation.id}`;
 		const list = element("ul", undefined, "task-tree task-root");
-		list.append(renderNode(conversation));
+		list.append(renderNode({ type: "conversation", ...conversation }));
 		card.append(list);
 		view.append(card);
 	}
@@ -643,7 +785,7 @@ function setupToolbar() {
 	if (page === "/chat" || page === "/tasks") {
 		if (conversationId) {
 			toolbar.className = "toolbar";
-			toolbar.append(page === "/chat" ? link("< Recent Chats", "/") : link("< All conversations", "/tasks"));
+			toolbar.append(page === "/chat" ? link("< Messages", "/") : link("< All conversations", "/tasks"));
 		}
 	} else if (page === "/memory") {
 		const records = Array.isArray(data) ? memoryRows() : data.records;
@@ -702,6 +844,7 @@ async function render() {
 	if (page === "/chat") await loadChats();
 	else if (page === "/memory") renderMemory();
 	else if (page === "/settings") renderSettings();
+	else if (page === "/chats") renderChatSettings();
 	else if (page === "/logs") renderLogs();
 	else if (page === "/tasks") renderTasks();
 	else if (page === "/scheduled") renderScheduled();

package/dist/web/page.js

@@ -5,7 +5,8 @@ function escapeHtml(text) {
 export function renderPage(page, state) {
     const active = page === "/" || page === "/chat" ? "/" : page;
     const navigation = [
-        ["/", "Recent Chats"],
+        ["/", "Messages"],
+        ["/chats", "Chats"],
         ["/tasks", "Tasks"],
         ["/scheduled", "Scheduled"],
         ["/logs", "Logs"],
@@ -19,7 +20,7 @@ export function renderPage(page, state) {
 <title>blue — pi-imessage</title><link rel="stylesheet" href="/assets/style.css">
 <script src="/assets/app.js" defer></script></head>
 <body><nav class="app-nav" aria-label="Main navigation">${navigation}</nav>
-<main class="content" id="main"><header class="page-header"><h1 id="title">Recent Chats</h1>
+<main class="content" id="main"><header class="page-header"><h1 id="title">Messages</h1>
 <div class="connection"><button id="refresh" type="button">Refresh</button></div></header>
 <div id="toolbar"></div><p id="notice" role="status" hidden></p><div id="view" aria-busy="true"></div>
 <details class="native-state"><summary>Native state</summary><pre id="state">${escapeHtml(state)}</pre></details></main>

package/dist/web/schedules.js

@@ -11,18 +11,9 @@ export function readSchedules(harness) {
             const task = await tx.task(schedule.taskId);
             const checkpoint = task?.state.checkpoint;
             const state = checkpoint && typeof checkpoint === "object" && !Array.isArray(checkpoint) ? checkpoint : undefined;
-            const executions = [];
-            let cursor;
-            do {
-                const page = await tx.scanTasks({ conversationId: schedule.conversationId, kind: EXECUTION_KIND }, 100, cursor);
-                executions.push(...page.items);
-                cursor = page.next;
-            } while (cursor);
-            // Native scans merge live/terminal records; their order is not execution chronology.
-            const runs = executions
-                .sort((a, b) => b.id - a.id)
-                .slice(0, 10)
-                .map((run) => {
+            // Occurrence IDs grow with admission time; the newest ten are the history shown.
+            const executions = await tx.scanTasks({ conversationId: schedule.conversationId, kind: EXECUTION_KIND, order: "descending" }, 10);
+            const runs = executions.items.map((run) => {
                 const outcome = run.state.outcome;
                 const result = outcome?.status === "completed" &&
                     outcome.result &&
@@ -38,9 +29,7 @@ export function readSchedules(harness) {
                     input: run.input,
                     status: outcome?.status ?? run.state.status,
                     result,
-                    error: outcome?.status === "failed" || outcome?.status === "faulted"
-                        ? outcome.error.message
-                        : undefined,
+                    error: outcome?.status === "failed" || outcome?.status === "faulted" ? outcome.error.message : undefined,
                     delivery: receipt?.textStatus ?? (result?.requestId ? "queued" : undefined),
                 };
             });