@kingcrab/pi-imessage 1.1.0 → 1.1.1

package/dist/agent/error-log.js

@@ -0,0 +1,37 @@
+const REASON_LIMIT = 200;
+const failedAssistant = (message) => message.role === "assistant" && message.stopReason === "error";
+/**
+ * Service-log error lines for failures that break normal operation (ADR 0053). Durable keeps a failed
+ * task only in its records, so without this an exhausted provider quota leaves stdout silent while the
+ * process, port and HTTP checks look healthy. Each error kind is one branch here; the first is a model
+ * call that ends failed, which leaves the chat or scheduled job without the answer it was waiting for.
+ */
+export function logErrors(harness) {
+    return harness.subscribeCommits(({ changes }) => {
+        for (const change of changes) {
+            if (change.type !== "task" || change.value.kind !== "pi.generation")
+                continue;
+            const task = change.value;
+            if (task.state.status !== "terminal")
+                continue;
+            const { outcome } = task.state;
+            if (outcome.status === "completed" || outcome.status === "aborted")
+                continue;
+            // The failing assistant message is committed together with the task and names provider and model.
+            const failed = changes
+                .flatMap((item) => item.type === "entry" && item.value.conversationId === task.conversationId
+                ? (item.value.model ?? [])
+                : [])
+                .find(failedAssistant);
+            console.error(new Date().toISOString(), "Model call failed", {
+                kind: task.kind,
+                task: task.id,
+                conversation: task.conversationId,
+                status: outcome.status,
+                provider: failed?.provider,
+                model: failed?.model,
+                reason: (outcome.error?.message ?? outcome.reason ?? "").slice(0, REASON_LIMIT),
+            });
+        }
+    });
+}

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";
@@ -105,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();
@@ -394,6 +396,7 @@ reloadHttpTransport) {
             closing ??= (async () => {
                 await Promise.allSettled([...operations]);
                 await progress.close();
+                stopErrorLog();
                 await owner.close(browser.close);
             })();
             return closing;
@@ -446,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();
             }
@@ -458,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

@@ -615,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) => [
@@ -623,70 +622,130 @@ 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) || [];
@@ -694,23 +753,29 @@ function renderTasks() {
 		if (descendants.length || more) {
 			const list = element("ul", undefined, "task-tree");
 			for (const child of descendants) list.append(renderNode(child));
-			if (more) list.append(element("li", "older tasks not listed", "meta"));
-			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);
 	}

package/dist/web/server.js

@@ -281,10 +281,21 @@ export async function startWeb(options) {
                 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)))

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;

package/dist/web/tasks.js

@@ -1,33 +1,139 @@
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { UserEntry, } from "@earendil-works/pi-durable";
 import { displayHistory, historyActivity } from "./history.js";
-/** Newest tasks listed per conversation; older finished ones are only flagged. */
+/** 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, their parent chains and the newest tasks of each conversation. Descending scans stop at the
- * window instead of reading the whole task history (earendil-works/pi#10546).
+ * 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,
                 });
-                const newest = await tx.scanTasks({ conversationId: conversation.id, order: "descending" }, RECENT_TASKS_PER_CONVERSATION + 1);
-                for (const task of newest.items.slice(0, RECENT_TASKS_PER_CONVERSATION))
-                    kept.set(task.id, task);
-                if (newest.items.length > RECENT_TASKS_PER_CONVERSATION)
-                    more[conversation.id] = true;
+                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)
@@ -85,13 +191,15 @@ export function readTaskTree(harness) {
                 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, more };
+        return { conversations, tasks, entries, more };
     }, BACKGROUND_CONTEXT);
 }

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

@@ -34,6 +34,7 @@ Accepted ADR files are never edited; this index records which ones are current.
 | [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
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kingcrab/pi-imessage",
-	"version": "1.1.0",
+	"version": "1.1.1",
 	"description": "A minimal, self-managing iMessage bot powered by Pi Durable",
 	"license": "MIT",
 	"repository": {