@oh-my-pi/pi-coding-agent 16.2.1 → 16.2.3

package/src/session/indexed-session-storage.ts

@@ -1,10 +1,20 @@
 import { toError } from "@oh-my-pi/pi-utils";
 import type { SessionStorage, SessionStorageStat, SessionStorageWriter } from "./session-storage";
+import {
+	overlayTitleSlotContent,
+	overlayTitleSlotPrefix,
+	parseTitleSlotFromContent,
+	type SessionTitleUpdate,
+	titleUpdateFromSlot,
+} from "./session-title-slot";
 
 export interface SessionStorageIndexEntry {
 	path: string;
 	size: number;
 	mtimeMs: number;
+	title?: string;
+	titleSource?: SessionTitleUpdate["source"];
+	titleUpdatedAt?: string;
 }
 
 export interface SessionStorageBackend {
@@ -12,8 +22,9 @@ export interface SessionStorageBackend {
 	loadIndex(): Promise<Iterable<SessionStorageIndexEntry>>;
 	readFull(path: string): Promise<string | null>;
 	readSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
-	writeFull(path: string, content: string, mtimeMs: number): Promise<void>;
+	writeFull(path: string, content: string, mtimeMs: number, title?: SessionTitleUpdate): Promise<void>;
 	append(path: string, line: string, mtimeMs: number): Promise<void>;
+	updateSessionTitle(path: string, title: SessionTitleUpdate, mtimeMs: number): Promise<void>;
 	truncate(path: string, mtimeMs: number): Promise<void>;
 	remove(paths: string[]): Promise<void>;
 	move(src: string, dst: string, mtimeMs: number): Promise<void>;
@@ -22,6 +33,9 @@ export interface SessionStorageBackend {
 interface IndexEntry {
 	size: number;
 	mtimeMs: number;
+	title?: string;
+	titleSource?: SessionTitleUpdate["source"];
+	titleUpdatedAt?: string;
 }
 
 interface EnqueueOptions {
@@ -64,6 +78,10 @@ function uniquePaths(paths: readonly string[]): string[] {
 	}
 	return out;
 }
+function titleUpdateForIndex(entry: IndexEntry): SessionTitleUpdate | undefined {
+	if (!entry.titleUpdatedAt) return undefined;
+	return { title: entry.title, source: entry.titleSource, updatedAt: entry.titleUpdatedAt };
+}
 
 export class IndexedSessionStorage implements SessionStorage {
 	readonly #backend: SessionStorageBackend;
@@ -89,7 +107,10 @@ export class IndexedSessionStorage implements SessionStorage {
 		const rows = await this.#backend.loadIndex();
 		this.#index.clear();
 		for (const row of rows) {
-			this.#setIndex(row.path, row.size, row.mtimeMs);
+			const title = row.titleUpdatedAt
+				? { title: row.title, source: row.titleSource, updatedAt: row.titleUpdatedAt }
+				: null;
+			this.#setIndex(row.path, row.size, row.mtimeMs, title);
 		}
 	}
 
@@ -112,8 +133,40 @@ export class IndexedSessionStorage implements SessionStorage {
 
 	writeTextSync(path: string, content: string): void {
 		const mtimeMs = this.#allocMtimeMs();
-		this.#setIndex(path, byteLength(content), mtimeMs);
-		this.#enqueuePath(path, () => this.#backend.writeFull(path, content, mtimeMs), { trackDrain: true });
+		const title = titleUpdateFromSlot(parseTitleSlotFromContent(content));
+		this.#setIndex(path, byteLength(content), mtimeMs, title ?? null);
+		this.#enqueuePath(path, () => this.#backend.writeFull(path, content, mtimeMs, title), { trackDrain: true });
+	}
+
+	async updateSessionTitle(path: string, title: SessionTitleUpdate): Promise<void> {
+		await this.#awaitPath(path);
+		const previous = this.#index.get(path);
+		if (!previous) throw enoent(path);
+		const mtimeMs = this.#allocMtimeMs();
+		const next = {
+			...previous,
+			title: title.title,
+			titleSource: title.source,
+			titleUpdatedAt: title.updatedAt,
+			mtimeMs,
+		};
+		this.#index.set(path, next);
+		try {
+			await this.#enqueuePath(path, () => this.#backend.updateSessionTitle(path, title, mtimeMs), {
+				trackDrain: false,
+			});
+		} catch (err) {
+			const current = this.#index.get(path);
+			if (
+				current?.mtimeMs === next.mtimeMs &&
+				current.title === next.title &&
+				current.titleSource === next.titleSource &&
+				current.titleUpdatedAt === next.titleUpdatedAt
+			) {
+				this.#index.set(path, previous);
+			}
+			throw toError(err);
+		}
 	}
 
 	statSync(path: string): SessionStorageStat {
@@ -144,29 +197,37 @@ export class IndexedSessionStorage implements SessionStorage {
 	}
 
 	async readText(path: string): Promise<string> {
-		if (!this.#index.has(path)) throw enoent(path);
+		const entry = this.#index.get(path);
+		if (!entry) throw enoent(path);
 		await this.#awaitPath(path);
 		const content = await this.#backend.readFull(path);
 		if (content === null) throw enoent(path);
-		return content;
+		const title = titleUpdateForIndex(entry);
+		return title ? overlayTitleSlotContent(content, title) : content;
 	}
 
 	async readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]> {
-		if (!this.#index.has(path)) throw enoent(path);
+		const entry = this.#index.get(path);
+		if (!entry) throw enoent(path);
 		const prefixLimit = normalizeByteLimit(prefixBytes);
 		const suffixLimit = normalizeByteLimit(suffixBytes);
 		if (prefixLimit === 0 && suffixLimit === 0) return ["", ""];
 		await this.#awaitPath(path);
-		return this.#backend.readSlices(path, prefixLimit, suffixLimit);
+		const [prefix, suffix] = await this.#backend.readSlices(path, prefixLimit, suffixLimit);
+		const title = titleUpdateForIndex(entry);
+		return [title ? overlayTitleSlotPrefix(prefix, prefixLimit, title) : prefix, suffix];
 	}
 
 	async writeText(path: string, content: string): Promise<void> {
 		await this.#awaitPath(path);
 		const previous = this.#index.get(path);
 		const mtimeMs = this.#allocMtimeMs();
-		this.#setIndex(path, byteLength(content), mtimeMs);
+		const title = titleUpdateFromSlot(parseTitleSlotFromContent(content));
+		this.#setIndex(path, byteLength(content), mtimeMs, title ?? null);
 		try {
-			await this.#enqueuePath(path, () => this.#backend.writeFull(path, content, mtimeMs), { trackDrain: false });
+			await this.#enqueuePath(path, () => this.#backend.writeFull(path, content, mtimeMs, title), {
+				trackDrain: false,
+			});
 		} catch (err) {
 			this.#restoreIndex(path, previous);
 			throw toError(err);
@@ -249,7 +310,7 @@ export class IndexedSessionStorage implements SessionStorage {
 
 	_truncateForWriter(path: string): number {
 		const mtimeMs = this.#allocMtimeMs();
-		this.#setIndex(path, 0, mtimeMs);
+		this.#setIndex(path, 0, mtimeMs, null);
 		return mtimeMs;
 	}
 
@@ -293,8 +354,20 @@ export class IndexedSessionStorage implements SessionStorage {
 		}
 	}
 
-	#setIndex(path: string, size: number, mtimeMs: number): void {
-		this.#index.set(path, { size, mtimeMs });
+	#setIndex(
+		path: string,
+		size: number,
+		mtimeMs: number,
+		title: SessionTitleUpdate | null | undefined = undefined,
+	): void {
+		const current = title === undefined ? this.#index.get(path) : undefined;
+		this.#index.set(path, {
+			size,
+			mtimeMs,
+			title: title === undefined ? current?.title : (title?.title ?? undefined),
+			titleSource: title === undefined ? current?.titleSource : (title?.source ?? undefined),
+			titleUpdatedAt: title === undefined ? current?.titleUpdatedAt : (title?.updatedAt ?? undefined),
+		});
 		if (mtimeMs > this.#nextMtimeMs) this.#nextMtimeMs = mtimeMs;
 	}
 

package/src/session/messages.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from "bun:test";
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import {
+	type CustomMessage,
+	convertToLlm,
+	INTERRUPTED_THINKING_MESSAGE_TYPE,
+	SKILL_PROMPT_MESSAGE_TYPE,
+	type SkillPromptDetails,
+} from "./messages";
+
+function customMessage(customType: string, attribution: "agent" | "user"): CustomMessage<SkillPromptDetails> {
+	return {
+		role: "custom",
+		customType,
+		content: "Use this skill.",
+		display: true,
+		details: { name: "atomic-commit", path: "/tmp/SKILL.md", lineCount: 1 },
+		attribution,
+		timestamp: 1,
+	};
+}
+
+const interruptedUsage: AssistantMessage["usage"] = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+function abortedAssistant(content: AssistantMessage["content"]): AssistantMessage {
+	return {
+		role: "assistant",
+		content,
+		api: "anthropic-messages",
+		provider: "anthropic",
+		model: "claude-sonnet-4-5",
+		usage: interruptedUsage,
+		stopReason: "aborted",
+		timestamp: 1,
+	};
+}
+
+function interruptedThinkingContinuity(): CustomMessage {
+	return {
+		role: "custom",
+		customType: INTERRUPTED_THINKING_MESSAGE_TYPE,
+		content: "preserved reasoning",
+		display: false,
+		attribution: "agent",
+		timestamp: 2,
+	};
+}
+
+describe("convertToLlm", () => {
+	it("presents user-invoked skill prompts as user turns", () => {
+		const [message] = convertToLlm([customMessage(SKILL_PROMPT_MESSAGE_TYPE, "user")]);
+
+		expect(message?.role).toBe("user");
+		if (message?.role !== "user") {
+			throw new Error(`Expected user role, received ${message?.role ?? "none"}`);
+		}
+		expect(message.attribution).toBe("user");
+	});
+
+	it("keeps auto-applied skill prompts and other custom messages as developer turns", () => {
+		const [autoSkill, otherCustom] = convertToLlm([
+			customMessage(SKILL_PROMPT_MESSAGE_TYPE, "agent"),
+			customMessage("extension-note", "user"),
+		]);
+
+		expect(autoSkill?.role).toBe("developer");
+		expect(otherCustom?.role).toBe("developer");
+	});
+
+	it("strips the demoted trailing thinking run from the assistant LLM view when its continuity message follows", () => {
+		const messages: AgentMessage[] = [
+			abortedAssistant([
+				{ type: "text", text: "partial answer" },
+				{ type: "thinking", thinking: "interrupted reasoning" },
+			]),
+			interruptedThinkingContinuity(),
+		];
+
+		const llm = convertToLlm(messages);
+		const assistant = llm.find(entry => entry.role === "assistant");
+		expect(Array.isArray(assistant?.content) && assistant.content.map(block => block.type)).toEqual(["text"]);
+		expect(llm.some(entry => entry.role === "developer")).toBe(true);
+	});
+
+	it("keeps trailing thinking on the assistant LLM view when no continuity message follows", () => {
+		const messages: AgentMessage[] = [
+			abortedAssistant([
+				{ type: "text", text: "partial answer" },
+				{ type: "thinking", thinking: "interrupted reasoning" },
+			]),
+		];
+
+		const llm = convertToLlm(messages);
+		const assistant = llm.find(entry => entry.role === "assistant");
+		expect(Array.isArray(assistant?.content) && assistant.content.map(block => block.type)).toEqual([
+			"text",
+			"thinking",
+		]);
+	});
+
+	it("keeps a signed (complete) trailing thinking block in the assistant LLM view even with a continuity message", () => {
+		const messages: AgentMessage[] = [
+			abortedAssistant([
+				{ type: "text", text: "partial answer" },
+				{ type: "thinking", thinking: "complete reasoning", thinkingSignature: "sig" },
+			]),
+			interruptedThinkingContinuity(),
+		];
+
+		const llm = convertToLlm(messages);
+		const assistant = llm.find(entry => entry.role === "assistant");
+		expect(Array.isArray(assistant?.content) && assistant.content.map(block => block.type)).toEqual([
+			"text",
+			"thinking",
+		]);
+	});
+});

package/src/session/messages.ts

@@ -18,6 +18,7 @@ import type {
 	TextContent,
 	UserMessage,
 } from "@oh-my-pi/pi-ai";
+import * as AIError from "@oh-my-pi/pi-ai/error";
 import { prompt } from "@oh-my-pi/pi-utils";
 import userInterjectionTemplate from "../prompts/steering/user-interjection.md" with { type: "text" };
 
@@ -36,6 +37,97 @@ export const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
 export const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
 export const BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE = "background-tan-dispatch";
 
+/** Custom message type for hidden interrupted-thinking continuity context. */
+export const INTERRUPTED_THINKING_MESSAGE_TYPE = "interrupted-thinking";
+
+/** Metadata persisted with a hidden interrupted-thinking continuity message. */
+export interface InterruptedThinkingDetails {
+	interruptedAt: number;
+	provider: AssistantMessage["provider"];
+	model: string;
+	blockCount: number;
+}
+
+/** Pure helper result for persisting interrupted thinking outside the assistant turn. */
+export interface DemotedInterruptedThinking {
+	reasoning: string;
+	strippedContent: AssistantMessage["content"];
+	blockCount: number;
+}
+
+/**
+ * Demote a trailing run of *incomplete* interrupted-thinking from an assistant
+ * message — reasoning that was still streaming when the user aborted.
+ *
+ * A block joins the run only when it is a non-empty `thinking` block with no
+ * `thinkingSignature`. A signed/complete thinking block (Anthropic signature,
+ * OpenAI reasoning item id) is safely replayable, so it ends the run and stays
+ * in place — as do `redactedThinking` encrypted blobs, text, tool calls,
+ * empty-thinking blocks, and trailing empty text placeholders.
+ */
+export function demoteInterruptedThinking(
+	message: Pick<AssistantMessage, "content">,
+): DemotedInterruptedThinking | undefined {
+	const content = message.content;
+	let scanEnd = content.length;
+	while (scanEnd > 0) {
+		const block = content[scanEnd - 1]!;
+		if (block.type !== "text" || block.text.trim().length > 0) {
+			break;
+		}
+		scanEnd--;
+	}
+
+	let runStart = scanEnd;
+	while (runStart > 0) {
+		const block = content[runStart - 1]!;
+		if (block.type !== "thinking" || block.thinking.trim().length === 0 || block.thinkingSignature) {
+			break;
+		}
+		runStart--;
+	}
+
+	const blockCount = scanEnd - runStart;
+	if (blockCount === 0) {
+		return undefined;
+	}
+
+	const reasoningBlocks: string[] = [];
+	for (let index = runStart; index < scanEnd; index++) {
+		const block = content[index]!;
+		if (block.type === "thinking") {
+			reasoningBlocks.push(block.thinking.trim());
+		}
+	}
+
+	return {
+		reasoning: reasoningBlocks.join("\n\n"),
+		strippedContent: content.slice(0, runStart),
+		blockCount,
+	};
+}
+
+/**
+ * True when the assistant turn at `messages[index]` is immediately followed by
+ * its hidden `interrupted-thinking` continuity message — the marker that a
+ * trailing thinking run was demoted on user interrupt. The run stays on the
+ * persisted/displayed assistant message; this flag tells the LLM path to drop it.
+ */
+function followedByInterruptedThinking(messages: AgentMessage[], index: number): boolean {
+	const next = messages[index + 1];
+	return next !== undefined && next.role === "custom" && next.customType === INTERRUPTED_THINKING_MESSAGE_TYPE;
+}
+
+/**
+ * Drop the demoted trailing thinking run from an assistant message for the LLM
+ * view only. The run is incomplete and unsigned, so providers reject it; the
+ * continuity message that follows carries the reasoning instead.
+ */
+function stripDemotedThinkingForLlm(message: AssistantMessage): AssistantMessage {
+	const demoted = demoteInterruptedThinking(message);
+	return demoted ? { ...message, content: demoted.strippedContent } : message;
+}
+
 /** Details persisted on a `/tan` background-dispatch breadcrumb. */
 export interface BackgroundTanDispatchDetails {
 	jobId: string;
@@ -70,11 +162,10 @@ export interface SkillPromptDetails {
  *  (fallback error emission) read it via `isSilentAbort`. */
 export const SILENT_ABORT_MARKER = "__omp.silent_abort__";
 
-/** Type-guard for `SILENT_ABORT_MARKER`. Renderers MUST branch on this rather
- *  than string-comparing inline so refactors to the marker constant (e.g.,
- *  namespacing changes) propagate through every consumer in lockstep. */
-export function isSilentAbort(errorMessage: string | undefined): boolean {
-	return errorMessage === SILENT_ABORT_MARKER;
+/** Type-guard for silent aborts. Renderers MUST call this helper so structured
+ *  `errorId` and legacy persisted marker messages stay in lockstep. */
+export function isSilentAbort(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean {
+	return AIError.is(message.errorId, AIError.Flag.SilentAbort) || message.errorMessage === SILENT_ABORT_MARKER;
 }
 
 /** Reason threaded through `AbortController.abort(reason)` when the user aborts
@@ -84,12 +175,12 @@ export function isSilentAbort(errorMessage: string | undefined): boolean {
  *  abort, but interactive renderers suppress this redundant transcript line. */
 export const USER_INTERRUPT_LABEL = "Interrupted by user";
 
-export function isUserInterruptAbort(errorMessage: string | undefined): boolean {
-	return errorMessage === USER_INTERRUPT_LABEL;
+export function isUserInterruptAbort(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean {
+	return AIError.is(message.errorId, AIError.Flag.UserInterrupt) || message.errorMessage === USER_INTERRUPT_LABEL;
 }
 
-export function shouldRenderAbortReason(errorMessage: string | undefined): boolean {
-	return !isSilentAbort(errorMessage) && !isUserInterruptAbort(errorMessage);
+export function shouldRenderAbortReason(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean {
+	return !isSilentAbort(message) && !isUserInterruptAbort(message);
 }
 
 /** Sentinel `errorMessage` the agent stamps on any abort that carried no custom
@@ -101,9 +192,17 @@ export const GENERIC_ABORT_SENTINEL = "Request was aborted";
  *  no threaded reason fall back to the retry-aware generic label. Call
  *  `shouldRenderAbortReason` before rendering when user interrupts should stay
  *  visually quiet. */
-export function resolveAbortLabel(errorMessage: string | undefined, retryAttempt = 0): string {
-	if (errorMessage && errorMessage !== GENERIC_ABORT_SENTINEL && !isSilentAbort(errorMessage)) {
-		return errorMessage;
+export function resolveAbortLabel(
+	message: Pick<AssistantMessage, "errorId" | "errorMessage">,
+	retryAttempt = 0,
+): string {
+	const genericAbort =
+		AIError.is(message.errorId, AIError.Flag.Abort) ||
+		!message.errorMessage ||
+		message.errorMessage === GENERIC_ABORT_SENTINEL ||
+		isSilentAbort(message);
+	if (!genericAbort) {
+		return message.errorMessage!;
 	}
 	if (retryAttempt > 0) {
 		return `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`;
@@ -451,21 +550,32 @@ export function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: Assis
 	if (message.providerPayload?.type !== "openaiResponsesHistory") {
 		return message;
 	}
+	// Only GitHub Copilot rejects replayed assistant-side native history on a
+	// warmed (resumed) session with HTTP 401 — that is the sole reason this strip
+	// exists. For every other Responses-family provider (OpenAI, OpenAI-Codex,
+	// Azure) the encrypted reasoning and native response items are self-contained
+	// and MUST survive rehydration: remote compaction replays them to rebuild
+	// faithful native history (user + assistant turns + encrypted reasoning), and
+	// same-model live turns reuse them for prompt-cache continuity. Stripping them
+	// for all providers is what left resumed sessions compacting tool-call-only
+	// history with no reasoning and no assistant prose.
+	if (message.provider !== "github-copilot") {
+		return message;
+	}
 
 	let didSanitizeContent = false;
 	const sanitizedContent = message.content.map(block => {
 		if (block.type !== "thinking" || block.thinkingSignature === undefined) {
 			return block;
 		}
-
 		didSanitizeContent = true;
 		return { ...block, thinkingSignature: undefined };
 	});
 
-	// Strip the assistant-side native replay payload entirely.
-	// After rehydration it belongs to a previous live provider connection and
-	// replaying it on a warmed session causes 401 rejections from GitHub Copilot.
-	// User/developer payloads are preserved separately by the caller.
+	// Strip the assistant-side native replay payload entirely. After rehydration
+	// it belongs to a previous live Copilot connection and replaying it on a
+	// warmed session causes 401 rejections. User/developer payloads are preserved
+	// separately by the caller.
 	return {
 		...message,
 		...(didSanitizeContent ? { content: sanitizedContent } : {}),
@@ -473,6 +583,38 @@ export function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: Assis
 	};
 }
 
+function customMessageContentToLlmContent(content: CustomMessage["content"]): (TextContent | ImageContent)[] {
+	return typeof content === "string" ? [{ type: "text", text: content }] : content;
+}
+
+function isUserInvokedSkillPrompt(message: CustomMessage): boolean {
+	return message.customType === SKILL_PROMPT_MESSAGE_TYPE && message.attribution === "user";
+}
+
+function convertImageBearingCustomMessage(message: CustomMessage | HookMessage): Message[] | undefined {
+	if (typeof message.content === "string") return undefined;
+	const textBlocks = message.content.filter((content): content is TextContent => content.type === "text");
+	const imageBlocks = message.content.filter((content): content is ImageContent => content.type === "image");
+	if (imageBlocks.length === 0) return undefined;
+
+	const converted: Message[] = [];
+	if (textBlocks.length > 0) {
+		converted.push({
+			role: "developer",
+			content: textBlocks,
+			attribution: message.attribution,
+			timestamp: message.timestamp,
+		});
+	}
+	converted.push({
+		role: "user",
+		content: [{ type: "text", text: `Images attached to ${message.customType}.` }, ...imageBlocks],
+		attribution: message.attribution,
+		timestamp: message.timestamp,
+	});
+	return converted;
+}
+
 /**
  * Transform AgentMessages (including custom types) to LLM-compatible Messages.
  *
@@ -482,7 +624,7 @@ export function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: Assis
  * - Custom extensions and tools
  */
 export function convertToLlm(messages: AgentMessage[]): Message[] {
-	return messages.flatMap((m): Message[] => {
+	return messages.flatMap((m, index): Message[] => {
 		switch (m.role) {
 			case "bashExecution":
 				if (m.excludeFromContext) {
@@ -547,13 +689,42 @@ export function convertToLlm(messages: AgentMessage[]): Message[] {
 				}
 				return out;
 			}
-			case "custom":
-			case "hookMessage":
+			case "custom": {
+				if (isUserInvokedSkillPrompt(m)) {
+					return [
+						{
+							role: "user",
+							content: customMessageContentToLlmContent(m.content),
+							attribution: "user",
+							timestamp: m.timestamp,
+						},
+					];
+				}
+				const split = convertImageBearingCustomMessage(m);
+				if (split) return split;
+				const converted = convertMessageToLlm(m);
+				return converted ? [converted] : [];
+			}
+			case "hookMessage": {
+				const split = convertImageBearingCustomMessage(m);
+				if (split) return split;
+				const converted = convertMessageToLlm(m);
+				return converted ? [converted] : [];
+			}
+			case "assistant": {
+				// A user-interrupted turn keeps its trailing thinking run on the
+				// persisted/displayed message so reload and Ctrl+L rebuilds still
+				// show it. That run is incomplete/unsigned and gets rejected on
+				// resend, so strip it here — LLM path only — when the hidden
+				// interrupted-thinking continuity message follows.
+				const source = followedByInterruptedThinking(messages, index) ? stripDemotedThinkingForLlm(m) : m;
+				const converted = convertMessageToLlm(source);
+				return converted ? [converted] : [];
+			}
 			case "branchSummary":
 			case "compactionSummary":
 			case "user":
 			case "developer":
-			case "assistant":
 			case "toolResult": {
 				// Core roles share one transformer with agent-core —
 				// duplicating them here is how snapcompact frames once