@@ -11,6 +11,7 @@ import { publishCompanion, type CompanionPublisher } from "./companion-discovery
 import type { EventJournal } from "./event-journal.js";
 import { discoverMobileCommands } from "./mobile-commands.js";
 import type { RoutineRun } from "../../shared/routines.js";
+import { toolStatusLabel } from "../../shared/tool-summary.js";
 
 interface CompanionSource {
   state(): AppState;
@@ -375,11 +376,18 @@ function mobileRoutineRun(run: RoutineRun): Record<string, unknown> {
   return { id: run.id, routine: run.routineName, status: run.status, endedAt: run.endedAt ?? run.startedAt, ...(run.threadId ? { threadId: run.threadId } : {}) };
 }
 
-function mobileItem(item: ThreadItem): Record<string, unknown> {
+/** A transcript item as the phone receives it. Exported for tests. */
+export function mobileItem(item: ThreadItem): Record<string, unknown> {
   switch (item.kind) {
-    case "user": case "assistant": case "thinking": case "notice": return { id: item.id, kind: item.kind, text: item.text, at: item.at, ...(item.kind === "notice" ? { level: item.level } : {}) };
+    // Typed fields (docs/conversation-events.md) ride along for clients that read them; older phones ignore them.
+    case "assistant": return { id: item.id, kind: item.kind, text: item.text, at: item.at, ...(item.phase ? { phase: item.phase } : {}), ...(item.outcome ? { outcome: item.outcome } : {}) };
+    case "thinking": return { id: item.id, kind: item.kind, text: item.text, at: item.at, ...(item.reasoning ? { reasoning: item.reasoning } : {}), ...(item.outcome ? { outcome: item.outcome } : {}) };
+    case "user": case "notice": return { id: item.id, kind: item.kind, text: item.text, at: item.at, ...(item.kind === "notice" ? { level: item.level } : {}) };
     case "approval": return { id: item.id, kind: item.kind, question: item.question, detail: item.detail, answer: item.answer, ...(item.decidedBy?.source === "policy" ? { auto: item.decidedBy.ruleId.slice("policy:".length) } : item.decidedBy && item.decidedBy.decision !== "ask" ? { auto: "rule" } : {}), at: item.at };
-    case "tool": return { id: item.id, kind: item.kind, title: item.title, status: item.status, ok: item.ok, at: item.at };
+    // A phone that reads only title and status shows every finished tool as done, so a finished tool
+    // that did not succeed says how it ended in its title.
+    case "tool": return { id: item.id, kind: item.kind, title: item.status === "done" && (item.outcome ? item.outcome !== "succeeded" : item.ok === false) ? `${item.title} · ${toolStatusLabel(item)}` : item.title,
+      status: item.status, ok: item.ok, ...(item.outcome ? { outcome: item.outcome } : {}), at: item.at };
     case "route": return { id: item.id, kind: item.kind, text: `${item.backend} · ${item.model || "default"}`, at: item.at };
   }
 }
 
@@ -212,19 +212,24 @@ function merge(previous: ThreadEvent, next: ThreadEvent): ThreadEvent {
 }
 
 /**
- * A thread's transcript rebuilt from journaled events, applied as the runner applies them: an
- * `item` appends, an `item_update` merges into the item with that id and is ignored when there is
- * none.
+ * A thread's transcript rebuilt from journaled events, applied as clients apply them: an `item` is
+ * an upsert by id (appended when new, replacing the item otherwise), and an `item_update` merges
+ * into the item with that id and is ignored when there is none. So a frame delivered twice changes
+ * nothing, and items keep their identity: two items never merge unless they share an id.
  */
 export function replayItems(entries: Iterable<JournalEntry | ThreadEvent>, threadId: string): ThreadItem[] {
   const items: ThreadItem[] = [];
+  const index = new Map<string, number>();
   for (const entry of entries) {
     const event = "event" in entry ? entry.event : entry;
     if (event.threadId !== threadId) continue;
-    if (event.type === "item") items.push(event.item);
-    else if (event.type === "item_update") {
-      const index = items.findIndex((item) => item.id === event.id);
-      if (index >= 0) items[index] = { ...items[index], ...event.patch } as ThreadItem;
+    if (event.type === "item") {
+      const at = index.get(event.item.id);
+      if (at === undefined) { index.set(event.item.id, items.length); items.push(event.item); }
+      else items[at] = event.item;
+    } else if (event.type === "item_update") {
+      const at = index.get(event.id);
+      if (at !== undefined) items[at] = { ...items[at], ...event.patch } as ThreadItem;
     }
   }
   return items;
 
@@ -200,6 +200,20 @@ export class ThreadRunner {
       });
       l = { abort: null, run: null, backend: null, pending: new Map(), items, status: "idle", conversation: initialConversation(), attempt: null };
       this.live.set(threadId, l);
+      // Settle it everywhere once, not only in this window: save it for the next process, and send the
+      // change through the event stream so the journal and paired clients that resume from it see it too.
+      const stored = this.o.store.items(threadId);
+      const settled = items.flatMap((item, i) => {
+        const before = stored[i];
+        if (!before || item === before) return [];
+        const patch = Object.fromEntries(Object.entries(item).filter(([key, value]) => (before as Record<string, unknown>)[key] !== value));
+        return [{ id: item.id, patch: patch as Partial<ThreadItem> }];
+      });
+      if (settled.length) {
+        try { this.persistItems(threadId, l); }
+        catch (error) { console.error("[modex] could not save settled items:", error); }
+        for (const { id, patch } of settled) this.o.emit({ threadId, type: "item_update", id, patch });
+      }
     }
     return l;
   }
 
@@ -11,73 +11,14 @@ import type { Backend, TurnResult, TurnSink } from "../src/main/engine/backends/
 import type { ThreadEvent, ThreadItem } from "../src/shared/types.js";
 import { FakeProcess, fakeSpawn } from "./fakeproc.js";
 import { gitRepo, tmpdir } from "./helpers.js";
+import { CLAUDE_SESSION, CODEX_THREAD, FIXTURES, claudeStream, codexServer, fixture } from "./conversation-fixtures.js";
 import { CONVERSATION_SCHEMA, applyConversationEvent, finalAnswerIndex, itemFacts, parseConversationEvent, projectConversation, type AttemptMark, type ConversationEvent, type ConversationItem, type NativeRef, type Observation, type TurnRef } from "../src/shared/conversation-events.js";
 
-// Sanitized captures from real CLI runs (see test/fixtures/conversation/README.md). Replaying them
-// tests the adapters against bytes the CLIs really sent; it is not live-provider acceptance.
-const FIXTURES = fileURLToPath(new URL("../../test/fixtures/conversation/", import.meta.url));
-const fixture = (name: string) => fs.readFileSync(path.join(FIXTURES, name), "utf8").split("\n").filter((l) => l.trim());
-const CODEX_THREAD = "01a14da2-063a-77a3-9092-0e3543b84bd0";
-const CLAUDE_SESSION = "852a2cd1-6453-4922-802d-193d60be6980";
-
 /** What a test reads off a transcript item, typed loosely so it also reads items written before CF-1. */
 type Loose = ThreadItem & Record<string, unknown>;
 const conversation = (items: ThreadItem[]) => items.filter((i) => i.kind === "assistant" || i.kind === "thinking" || i.kind === "tool") as Loose[];
 const origin = (item: Loose) => item.origin as { thread: string; turn: string; attempt: string; backend: string; native: { runtime: string; thread?: string; turn?: string; item: string; part?: string } } | undefined;
 
-/** Writes `text` to the fake CLI's stdout in chunks of 1, 2, 3, 5 and 7 bytes, splitting UTF-8 sequences and JSON lines. */
-async function trickle(proc: FakeProcess, text: string): Promise<void> {
-  const bytes = Buffer.from(text, "utf8");
-  const sizes = [1, 2, 3, 5, 7];
-  for (let at = 0, n = 0; at < bytes.length; n++) {
-    const size = sizes[n % sizes.length]!;
-    proc.stdout.write(bytes.subarray(at, at + size));
-    at += size;
-    if (n % 16 === 0) await new Promise((r) => setImmediate(r));
-  }
-}
-
-/**
- * Plays a captured app-server stream to CodexBackend. Setup requests are answered with the capture's
- * own thread and turn ids; each server request (an approval) waits for Modex's reply before the next line.
- */
-function codexServer(proc: FakeProcess, lines: string[], opts: { split?: boolean; close?: number } = {}) {
-  const turnId = (lines.map((l) => JSON.parse(l) as { method?: string; params?: { turn?: { id?: string } } }).find((m) => m.method === "turn/started")?.params?.turn?.id) ?? "turn-1";
-  const threadId = (JSON.parse(lines[0]!) as { params?: { threadId?: string; thread?: { id?: string } } }).params;
-  const tid = threadId?.threadId ?? threadId?.thread?.id ?? CODEX_THREAD;
-  let played: Promise<void> | null = null;
-  proc.stdin.on("data", (d: Buffer) => {
-    for (const line of d.toString().split("\n")) {
-      if (!line.trim()) continue;
-      const msg = JSON.parse(line) as { id?: number; method?: string };
-      if (msg.method === "initialize") proc.emitLine({ id: msg.id, result: { userAgent: "fixture/0.163.0" } });
-      else if (msg.method === "thread/start" || msg.method === "thread/resume") proc.emitLine({ id: msg.id, result: { thread: { id: tid } } });
-      else if (msg.method === "turn/start") {
-        proc.emitLine({ id: msg.id, result: { turn: { id: turnId } } });
-        played ??= (async () => {
-          for (const raw of lines) {
-            const m = JSON.parse(raw) as { id?: number; method?: string };
-            if (opts.split) await trickle(proc, raw + "\n"); else proc.stdout.write(raw + "\n");
-            if (m.id !== undefined && m.method) await proc.waitFor((l) => { const r = JSON.parse(l) as { id?: number; result?: unknown }; return r.id === m.id && r.result !== undefined; }, 5000);
-          }
-          if (opts.close !== undefined) proc.close(opts.close);
-        })();
-      }
-    }
-  });
-}
-
-/** Plays a captured `claude -p` stream. Each `control_request` waits for Modex's `control_response`. */
-async function claudeStream(proc: FakeProcess, lines: string[], opts: { split?: boolean } = {}): Promise<void> {
-  await proc.waitFor((l) => l.includes('"type":"user"'));
-  for (const raw of lines) {
-    const m = JSON.parse(raw) as { type: string; request_id?: string };
-    if (opts.split) await trickle(proc, raw + "\n"); else proc.stdout.write(raw + "\n");
-    if (m.type === "control_request") await proc.waitFor((l) => l.includes('"control_response"') && l.includes(m.request_id!), 5000);
-  }
-  proc.close(0);
-}
-
 /** A runner on a fresh store with the given backends, and a thread on `backend` whose approvals the test answers. */
 async function harness(backends: Partial<Record<"claude" | "codex" | "mock", Backend>>, backend: "claude" | "codex" | "mock", answer: (question: string) => "yes" | "no" = () => "yes") {
   const home = tmpdir("modex-conversation-");
 
@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { FakeProcess } from "./fakeproc.js";
+
+// Sanitized captures from real CLI runs (see test/fixtures/conversation/README.md). Replaying them
+// tests the adapters against bytes the CLIs really sent; it is not live-provider acceptance.
+export const FIXTURES = fileURLToPath(new URL("../../test/fixtures/conversation/", import.meta.url));
+export const fixture = (name: string) => fs.readFileSync(path.join(FIXTURES, name), "utf8").split("\n").filter((l) => l.trim());
+export const CODEX_THREAD = "01a14da2-063a-77a3-9092-0e3543b84bd0";
+export const CLAUDE_SESSION = "852a2cd1-6453-4922-802d-193d60be6980";
+
+/** Writes `text` to the fake CLI's stdout in chunks of 1, 2, 3, 5 and 7 bytes, splitting UTF-8 sequences and JSON lines. */
+export async function trickle(proc: FakeProcess, text: string): Promise<void> {
+  const bytes = Buffer.from(text, "utf8");
+  const sizes = [1, 2, 3, 5, 7];
+  for (let at = 0, n = 0; at < bytes.length; n++) {
+    const size = sizes[n % sizes.length]!;
+    proc.stdout.write(bytes.subarray(at, at + size));
+    at += size;
+    if (n % 16 === 0) await new Promise((r) => setImmediate(r));
+  }
+}
+
+/**
+ * Plays a captured app-server stream to CodexBackend. Setup requests are answered with the capture's
+ * own thread and turn ids; each server request (an approval) waits for Modex's reply before the next line.
+ */
+export function codexServer(proc: FakeProcess, lines: string[], opts: { split?: boolean; close?: number } = {}) {
+  const turnId = (lines.map((l) => JSON.parse(l) as { method?: string; params?: { turn?: { id?: string } } }).find((m) => m.method === "turn/started")?.params?.turn?.id) ?? "turn-1";
+  const threadId = (JSON.parse(lines[0]!) as { params?: { threadId?: string; thread?: { id?: string } } }).params;
+  const tid = threadId?.threadId ?? threadId?.thread?.id ?? CODEX_THREAD;
+  let played: Promise<void> | null = null;
+  proc.stdin.on("data", (d: Buffer) => {
+    for (const line of d.toString().split("\n")) {
+      if (!line.trim()) continue;
+      const msg = JSON.parse(line) as { id?: number; method?: string };
+      if (msg.method === "initialize") proc.emitLine({ id: msg.id, result: { userAgent: "fixture/0.163.0" } });
+      else if (msg.method === "thread/start" || msg.method === "thread/resume") proc.emitLine({ id: msg.id, result: { thread: { id: tid } } });
+      else if (msg.method === "turn/start") {
+        proc.emitLine({ id: msg.id, result: { turn: { id: turnId } } });
+        played ??= (async () => {
+          for (const raw of lines) {
+            const m = JSON.parse(raw) as { id?: number; method?: string };
+            if (opts.split) await trickle(proc, raw + "\n"); else proc.stdout.write(raw + "\n");
+            if (m.id !== undefined && m.method) await proc.waitFor((l) => { const r = JSON.parse(l) as { id?: number; result?: unknown }; return r.id === m.id && r.result !== undefined; }, 5000);
+          }
+          if (opts.close !== undefined) proc.close(opts.close);
+        })();
+      }
+    }
+  });
+}
+
+/** Plays a captured `claude -p` stream. Each `control_request` waits for Modex's `control_response`. */
+export async function claudeStream(proc: FakeProcess, lines: string[], opts: { split?: boolean } = {}): Promise<void> {
+  await proc.waitFor((l) => l.includes('"type":"user"'));
+  for (const raw of lines) {
+    const m = JSON.parse(raw) as { type: string; request_id?: string };
+    if (opts.split) await trickle(proc, raw + "\n"); else proc.stdout.write(raw + "\n");
+    if (m.type === "control_request") await proc.waitFor((l) => l.includes('"control_response"') && l.includes(m.request_id!), 5000);
+  }
+  proc.close(0);
+}
+