diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index f33592b..66b45a5 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -18,7 +18,7 @@
   "main": "dist-electron/main/index.mjs",
   "scripts": {
     "build:core": "pnpm --dir ../../packages/core build",
-    "predev": "pnpm build:core",
+    "predev": "pnpm build:core && pnpm build:electron",
     "dev": "concurrently -k \"vite --host 127.0.0.1\" \"wait-on tcp:5173 && cross-env VITE_DEV_SERVER_URL=http://127.0.0.1:5173 electron .\"",
     "prebuild": "pnpm build:core",
     "build:electron": "tsup",
diff --git a/apps/desktop/src/main/index.ts b/apps/desktop/src/main/index.ts
index 4cfc172..becc3fd 100644
--- a/apps/desktop/src/main/index.ts
+++ b/apps/desktop/src/main/index.ts
@@ -35,6 +35,7 @@ import { AppSettings } from "./app-settings";
 import { listCodexThemes } from "./themes";
 import {
   archiveSession,
+  deleteSession,
   listSessions,
   setSessionPinned,
   unarchiveSession,
@@ -254,6 +255,7 @@ function registerIpc(): void {
   ipcMain.handle("sessions:pin", (_event, id: string, pinned: boolean) => setSessionPinned(id, pinned));
   ipcMain.handle("sessions:archive", (_event, id: string) => archiveSession(id));
   ipcMain.handle("sessions:unarchive", (_event, id: string) => unarchiveSession(id));
+  ipcMain.handle("sessions:delete", (_event, id: string) => deleteSession(id));
 
   ipcMain.handle("auth:status", async (): Promise<ProviderStatus[]> => {
     const credentialStore = await createDSCodeCredentialStore();
diff --git a/apps/desktop/src/main/session-index.ts b/apps/desktop/src/main/session-index.ts
index 44af2b0..d9e9e1a 100644
--- a/apps/desktop/src/main/session-index.ts
+++ b/apps/desktop/src/main/session-index.ts
@@ -33,6 +33,10 @@ export async function unarchiveSession(id: string): Promise<SessionSummary | und
   });
 }
 
+export async function deleteSession(id: string): Promise<boolean> {
+  return withStore((store) => store.delete(id));
+}
+
 function toSessionSummary(thread: Awaited<ReturnType<typeof listDSCodeThreads>>[number]): SessionSummary {
   return {
     path: thread.sessionPath,
diff --git a/apps/desktop/src/preload/index.ts b/apps/desktop/src/preload/index.ts
index d010fa4..22e53d4 100644
--- a/apps/desktop/src/preload/index.ts
+++ b/apps/desktop/src/preload/index.ts
@@ -44,6 +44,7 @@ const api: DesktopApi & { onAppCommand(listener: (command: string) => void): ()
     pin: (id, pinned) => ipcRenderer.invoke("sessions:pin", id, pinned),
     archive: (id) => ipcRenderer.invoke("sessions:archive", id),
     unarchive: (id) => ipcRenderer.invoke("sessions:unarchive", id),
+    delete: (id) => ipcRenderer.invoke("sessions:delete", id),
   },
   auth: {
     status: () => ipcRenderer.invoke("auth:status"),
diff --git a/apps/desktop/src/renderer/App.tsx b/apps/desktop/src/renderer/App.tsx
index 7f6eeb6..ef3262a 100644
--- a/apps/desktop/src/renderer/App.tsx
+++ b/apps/desktop/src/renderer/App.tsx
@@ -1,4 +1,5 @@
 import {
+  memo,
   useCallback,
   useEffect,
   useMemo,
@@ -22,6 +23,7 @@ import {
   CircleAlert,
   CircleStop,
   Code2,
+  Copy,
   ExternalLink,
   Eye,
   File as FileIcon,
@@ -45,6 +47,7 @@ import {
   Paperclip,
   PanelLeft,
   PanelRight,
+  Pencil,
   Plus,
   Search,
   Settings,
@@ -56,6 +59,7 @@ import {
   X,
 } from "lucide-react";
 import type {
+  AgentEvent,
   AgentSnapshot,
   AgentSessionStats,
   AuthUiEvent,
@@ -76,8 +80,10 @@ import type {
 import { AUTH_PROMPT_CANCEL_VALUE } from "../shared/types";
 import {
   applyAgentEvent,
+  coalesceStreamingAgentEvents,
   getAssistantActivity,
   groupConversation,
+  isStreamingAgentEvent,
   normalizeMessages,
   optimisticUserMessage,
   splitAssistantTurn,
@@ -159,6 +165,9 @@ export default function App() {
   const [sessionStats, setSessionStats] = useState<AgentSessionStats>();
   const [draft, setDraft] = useState("");
   const [attachments, setAttachments] = useState<Attachment[]>([]);
+  const [editingMessageId, setEditingMessageId] = useState<string>();
+  const [editingText, setEditingText] = useState("");
+  const [editingSubmitting, setEditingSubmitting] = useState(false);
   const [previewImage, setPreviewImage] = useState<PreviewImage>();
   const [running, setRunning] = useState(false);
   const [loading, setLoading] = useState(true);
@@ -180,6 +189,7 @@ export default function App() {
   const [sessionQuery, setSessionQuery] = useState("");
   const [toast, setToast] = useState<{ message: string; type: "info" | "error" }>();
   const [uiRequest, setUiRequest] = useState<ExtensionUiRequest>();
+  const [resumingUiRequest, setResumingUiRequest] = useState(false);
   const [authEvent, setAuthEvent] = useState<AuthUiEvent>();
   const authCancellationRef = useRef(false);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
@@ -191,6 +201,32 @@ export default function App() {
   const sidebarFooterRef = useRef<HTMLDivElement>(null);
   const previewRequestRef = useRef(0);
   const inspectorResizeCleanupRef = useRef<() => void>(() => undefined);
+  const pendingAgentEventsRef = useRef<AgentEvent[]>([]);
+  const pendingAgentFrameRef = useRef<number | undefined>(undefined);
+  const previewFileCandidatesRef = useRef<string[]>([]);
+
+  const flushPendingAgentEvents = useCallback(() => {
+    const frame = pendingAgentFrameRef.current;
+    if (frame !== undefined) window.cancelAnimationFrame(frame);
+    pendingAgentFrameRef.current = undefined;
+    const pending = pendingAgentEventsRef.current;
+    if (pending.length === 0) return;
+    pendingAgentEventsRef.current = [];
+    const events = coalesceStreamingAgentEvents(pending);
+    setMessages((current) => events.reduce((next, event) => applyAgentEvent(next, event), current));
+  }, []);
+
+  const enqueueAgentEvent = useCallback((event: AgentEvent) => {
+    if (!isStreamingAgentEvent(event)) {
+      flushPendingAgentEvents();
+      setMessages((current) => applyAgentEvent(current, event));
+      return;
+    }
+    pendingAgentEventsRef.current.push(event);
+    if (pendingAgentFrameRef.current === undefined) {
+      pendingAgentFrameRef.current = window.requestAnimationFrame(flushPendingAgentEvents);
+    }
+  }, [flushPendingAgentEvents]);
 
   const hydrateSnapshot = useCallback((snapshot: AgentSnapshot) => {
     setMessages(normalizeMessages(snapshot.messages));
@@ -220,6 +256,23 @@ export default function App() {
     }
   }, []);
 
+  const readAgentSnapshot = useCallback(async (): Promise<AgentSnapshot> => {
+    const [state, messageData, models, thinkingLevels, stats] = await Promise.all([
+      window.dscode.agent.command<Record<string, unknown>>("get_state"),
+      window.dscode.agent.command<{ messages: unknown[] }>("get_messages"),
+      window.dscode.agent.command<{ models: AgentSnapshot["models"] }>("get_available_models"),
+      window.dscode.agent.command<{ levels: string[] }>("get_available_thinking_levels"),
+      window.dscode.agent.command<AgentSessionStats>("get_session_stats").catch(() => undefined),
+    ]);
+    return {
+      state,
+      messages: messageData.messages,
+      models: models.models,
+      thinkingLevels: thinkingLevels.levels,
+      ...(stats ? { stats } : {}),
+    };
+  }, []);
+
   const openFilePreview = useCallback(async (filePath: string) => {
     const requestId = ++previewRequestRef.current;
     setContextCardOpen(false);
@@ -275,6 +328,9 @@ export default function App() {
     const providerStatuses = behavior?.providerStatuses ?? providers;
     const status = providerStatuses.find((candidate) => candidate.id === nextProvider);
     setUiRequest(undefined);
+    setEditingMessageId(undefined);
+    setEditingText("");
+    setEditingSubmitting(false);
     setActiveSession(sessionPath);
     activeCwdRef.current = cwd;
     setWorkspace(projectPath);
@@ -368,7 +424,9 @@ export default function App() {
             permission: "auto",
             sandbox: "workspace-write",
           });
-          if (!cancelled) hydrateSnapshot(snapshot);
+          if (!cancelled) {
+            hydrateSnapshot(snapshot);
+          }
         } catch (error) {
           if (!cancelled && !isAgentSessionClosedError(error)) {
             setToast({ message: cleanError(error instanceof Error ? error.message : String(error)), type: "error" });
@@ -384,7 +442,10 @@ export default function App() {
 
   useEffect(() => {
     const offEvent = window.dscode.agent.onEvent((event) => {
-      if (event.type === "agent_start") setRunning(true);
+      if (event.type === "agent_start") {
+        setResumingUiRequest(false);
+        setRunning(true);
+      }
       if (event.type === "agent_settled") {
         setRunning(false);
         setUiRequest(undefined);
@@ -396,14 +457,16 @@ export default function App() {
         if (request.method === "notify") {
           setToast({ message: request.message ?? t("app.notification"), type: request.notifyType === "error" ? "error" : "info" });
         } else if (["select", "confirm", "input", "editor"].includes(request.method)) {
+          setResumingUiRequest(false);
           setUiRequest(request);
         }
       }
-      setMessages((current) => applyAgentEvent(current, event));
+      enqueueAgentEvent(event);
     });
     const offError = window.dscode.agent.onError((message) => {
       if (isAgentSessionClosedError(message)) return;
       setRunning(false);
+      setResumingUiRequest(false);
       setUiRequest(undefined);
       setToast({ message: cleanError(message), type: "error" });
     });
@@ -425,8 +488,12 @@ export default function App() {
       offError();
       offAuth();
       offCommand?.();
+      const frame = pendingAgentFrameRef.current;
+      if (frame !== undefined) window.cancelAnimationFrame(frame);
+      pendingAgentFrameRef.current = undefined;
+      pendingAgentEventsRef.current = [];
     };
-  }, [refreshSessionStats, refreshSessions, t]);
+  }, [enqueueAgentEvent, refreshSessionStats, refreshSessions, t]);
 
   useEffect(() => {
     if (!accountMenuOpen) return;
@@ -524,10 +591,13 @@ export default function App() {
     return selected;
   };
 
-  const createNewThread = async () => {
+  const createNewThread = async (projectPath?: string) => {
     setMessages([]);
     setActiveSession(undefined);
-    await startAgent();
+    if (projectPath) {
+      setExpandedProjects((current) => new Set(current).add(projectPath));
+    }
+    await startAgent(projectPath, undefined, undefined, projectPath);
     textareaRef.current?.focus();
   };
 
@@ -546,18 +616,97 @@ export default function App() {
     await startAgent(session.cwd, session.path, undefined, projectPath);
   };
 
+  const deleteSession = useCallback(async (session: SessionSummary) => {
+    if (running) {
+      setToast({ message: t("status.cannotDeleteWhileRunning"), type: "error" });
+      return;
+    }
+    if (!window.confirm(t("sidebar.confirmDeleteSession", { title: session.title }))) return;
+    const wasActive = session.path === activeSession;
+    try {
+      if (wasActive) {
+        await window.dscode.agent.stop();
+        setRunning(false);
+        setMessages([]);
+        setActiveSession(undefined);
+      }
+      const deleted = await window.dscode.sessions.delete(session.id);
+      if (!deleted) throw new Error("The conversation could not be deleted");
+      setSessions((current) => current.filter((item) => item.id !== session.id));
+      if (wasActive) {
+        const projectPath = workspaces.some((item) => item.path === session.cwd) ? session.cwd : undefined;
+        await startAgent(session.cwd, undefined, undefined, projectPath);
+      } else {
+        await refreshSessions();
+      }
+    } catch (error) {
+      setToast({ message: cleanError(error instanceof Error ? error.message : String(error)), type: "error" });
+    }
+  }, [activeSession, refreshSessions, running, startAgent, t, workspaces]);
+
+  const editMessage = useCallback((message: ChatMessage) => {
+    if (running || editingMessageId) return;
+    setEditingMessageId(message.id);
+    setEditingText(message.text);
+  }, [editingMessageId, running]);
+
+  const cancelEditingMessage = useCallback(() => {
+    if (editingSubmitting) return;
+    setEditingMessageId(undefined);
+    setEditingText("");
+  }, [editingSubmitting]);
+
+  const submitEditingMessage = useCallback(async () => {
+    if (!editingMessageId || editingSubmitting || running) return;
+    const original = messages.find((message) => message.id === editingMessageId);
+    if (!original) return;
+    const text = editingText.trim();
+    const messageImages = original.images.map(({ data, mimeType }) => ({ data, mimeType }));
+    if (!text && messageImages.length === 0) return;
+    const images = messageImages.map((image) => ({ type: "image", ...image }));
+    // Replacing the session shortens the scrollable content. Treat that
+    // programmatic jump as a new tail-following sequence for the resend.
+    followingConversationTailRef.current = true;
+    previousConversationScrollTopRef.current = 0;
+    // Leave the inline editor immediately. The session rewrite and snapshot
+    // reload happen asynchronously, so keeping this state would briefly
+    // render a large editing box above the replacement turn.
+    setEditingMessageId(undefined);
+    setEditingText("");
+    setEditingSubmitting(true);
+    setRunning(true);
+    try {
+      await window.dscode.agent.command("prompt", { message: "/edit-last" });
+      const snapshot = await readAgentSnapshot();
+      hydrateSnapshot(snapshot);
+      setMessages((current) => [...current, optimisticUserMessage(text || t("composer.attachedImage"), false, messageImages)]);
+      setEditingSubmitting(false);
+      await window.dscode.agent.command("prompt", {
+        message: text || t("composer.describeImage"),
+        ...(images.length ? { images } : {}),
+      });
+    } catch (error) {
+      setRunning(false);
+      if (!isAgentSessionClosedError(error)) {
+        setToast({ message: cleanError(error instanceof Error ? error.message : String(error)), type: "error" });
+      }
+    } finally {
+      setEditingSubmitting(false);
+    }
+  }, [editingMessageId, editingSubmitting, editingText, hydrateSnapshot, messages, readAgentSnapshot, running, t]);
+
   const sendMessage = async () => {
     const text = draft.trim();
     if (!text && attachments.length === 0) return;
     const alreadyRunning = running;
-    setDraft("");
     const queued = alreadyRunning;
     const messageImages = attachments.map(({ data, mimeType }) => ({ data, mimeType }));
-    setMessages((current) => [...current, optimisticUserMessage(text || t("composer.attachedImage"), queued, messageImages)]);
     const images = messageImages.map((image) => ({ type: "image", ...image }));
-    setAttachments([]);
     setRunning(true);
     try {
+      setDraft("");
+      setMessages((current) => [...current, optimisticUserMessage(text || t("composer.attachedImage"), queued, messageImages)]);
+      setAttachments([]);
       await window.dscode.agent.command(alreadyRunning ? "steer" : "prompt", {
         message: text || t("composer.describeImage"),
         ...(images.length ? { images } : {}),
@@ -654,7 +803,6 @@ export default function App() {
     setThemes(await window.dscode.themes.list());
   };
 
-  const allTools = useMemo(() => messages.flatMap((message) => message.tools), [messages]);
   const previewFileCandidates = useMemo(() => {
     const seen = new Set<string>();
     const files: string[] = [];
@@ -676,12 +824,11 @@ export default function App() {
       }
       if (files.length === 6) break;
     }
-    for (const tool of [...allTools].reverse()) {
-      addFile(toolFilePath(tool));
-      if (files.length === 6) break;
-    }
+    const previous = previewFileCandidatesRef.current;
+    if (sameStringArray(previous, files)) return previous;
+    previewFileCandidatesRef.current = files;
     return files;
-  }, [activeSession, allTools, messages, workspace]);
+  }, [activeSession, messages, workspace]);
 
   useEffect(() => {
     let cancelled = false;
@@ -698,12 +845,32 @@ export default function App() {
         if (!cancelled) setRecentPreviewFiles([]);
       });
     return () => { cancelled = true; };
-  }, [previewFileCandidates]);
+  }, [activeSession, previewFileCandidates, workspace]);
+  const handlePreviewFile = useCallback((filePath: string) => {
+    void openFilePreview(filePath);
+  }, [openFilePreview]);
   const conversationGroups = useMemo(() => groupConversation(messages), [messages]);
+  const editableUserMessageId = [...conversationGroups].reverse().find((group) => group.type === "user")?.id;
   const latestAssistantGroup = [...conversationGroups].reverse().find((group) => group.type === "assistant");
-  const activeAssistantGroupId = running ? latestAssistantGroup?.id : undefined;
-  const activeAssistantHasWork = latestAssistantGroup?.type === "assistant"
-    && splitAssistantTurn(latestAssistantGroup.messages, running).work.length > 0;
+  const latestConversationGroup = conversationGroups.at(-1);
+  const latestAssistantPreview = latestAssistantGroup ? splitAssistantTurn(latestAssistantGroup.messages, false) : undefined;
+  const latestAssistantHasVisibleResponse = (latestAssistantPreview?.responses.length ?? 0) > 0;
+  const activityRunning = running && !editingSubmitting;
+  const latestAssistantIsActive = (
+    activityRunning
+    && latestConversationGroup?.type === "assistant"
+    && latestAssistantGroup?.type === "assistant"
+    && latestAssistantGroup.id === latestConversationGroup.id
+  ) || (
+    resumingUiRequest
+    && !latestAssistantHasVisibleResponse
+    && latestConversationGroup?.type === "assistant"
+    && latestAssistantGroup?.type === "assistant"
+    && latestAssistantGroup.id === latestConversationGroup.id
+  );
+  const activeAssistantGroupId = latestAssistantIsActive ? latestAssistantGroup?.id : undefined;
+  const activeAssistantHasWork = latestAssistantIsActive && latestAssistantGroup?.type === "assistant"
+    && splitAssistantTurn(latestAssistantGroup.messages, true).work.length > 0;
   const projectPaths = useMemo(() => new Set(workspaces.map((item) => item.path)), [workspaces]);
 
   const showPreviewPanel = () => {
@@ -828,28 +995,49 @@ export default function App() {
               const visibleTasks = showAll ? taskSource : taskSource.slice(0, PROJECT_TASK_PREVIEW_COUNT);
               return (
                 <div className="project-group" key={item.path}>
-                  <button
-                    className={`project-row ${workspace === item.path && !activeSession ? "active" : ""}`}
-                    onClick={() => toggleWorkspace(item)}
-                    title={item.path}
-                    aria-expanded={isExpanded}
-                  >
-                    {isExpanded ? <FolderOpen size={15} /> : <Folder size={15} />}
-                    <strong>{item.name}</strong>
-                  </button>
+                  <div className="project-row-shell">
+                    <button
+                      className={`project-row ${workspace === item.path && !activeSession ? "active" : ""}`}
+                      onClick={() => toggleWorkspace(item)}
+                      title={item.path}
+                      aria-expanded={isExpanded}
+                    >
+                      {isExpanded ? <FolderOpen size={15} /> : <Folder size={15} />}
+                      <strong>{item.name}</strong>
+                    </button>
+                    <button
+                      type="button"
+                      className="project-new-thread-button"
+                      onClick={() => void createNewThread(item.path)}
+                      aria-label={t("sidebar.newProjectThread", { project: item.name })}
+                      title={t("sidebar.newProjectThread", { project: item.name })}
+                    >
+                      <Plus size={14} />
+                    </button>
+                  </div>
                   {isExpanded && (
                     <div className="project-task-list">
                       {visibleTasks.length === 0 && <div className="project-task-empty">{t("sidebar.noProjectTasks")}</div>}
                       {visibleTasks.map((session) => (
-                        <button
-                          key={session.path}
-                          className={`project-task-row ${session.path === activeSession ? "active" : ""}`}
-                          onClick={() => void openSession(session)}
-                          title={session.title}
-                          aria-current={session.path === activeSession ? "page" : undefined}
-                        >
-                          <span>{session.title}</span>
-                        </button>
+                        <div className="session-row project-session-row" key={session.path}>
+                          <button
+                            className={`project-task-row ${session.path === activeSession ? "active" : ""}`}
+                            onClick={() => void openSession(session)}
+                            title={session.title}
+                            aria-current={session.path === activeSession ? "page" : undefined}
+                          >
+                            <SidebarSessionTitle>{session.title}</SidebarSessionTitle>
+                          </button>
+                          <button
+                            type="button"
+                            className="session-delete-button"
+                            onClick={() => void deleteSession(session)}
+                            aria-label={t("sidebar.deleteSession")}
+                            title={t("sidebar.deleteSession")}
+                          >
+                            <Trash2 size={14} />
+                          </button>
+                        </div>
                       ))}
                       {!query && taskSource.length > PROJECT_TASK_PREVIEW_COUNT && (
                         <button
@@ -878,14 +1066,24 @@ export default function App() {
           {recentSectionOpen && <>
             {recentTasks.length === 0 && <div className="sidebar-empty">{t("sidebar.noRecentTasks")}</div>}
             {recentTasks.map((session) => (
-              <button
-                key={session.path}
-                className={`thread-row recent-task-row ${session.path === activeSession ? "active" : ""}`}
-                onClick={() => void openSession(session)}
-              >
-                <span className="thread-copy"><strong>{session.title}</strong><small>{relativeTime(session.updatedAt, locale, t("status.now"))}</small></span>
-                <span className="task-dot" aria-hidden="true" />
-              </button>
+              <div className="session-row recent-session-row" key={session.path}>
+                <button
+                  className={`thread-row recent-task-row ${session.path === activeSession ? "active" : ""}`}
+                  onClick={() => void openSession(session)}
+                >
+                  <span className="thread-copy"><SidebarSessionTitle>{session.title}</SidebarSessionTitle><small>{relativeTime(session.updatedAt, locale, t("status.now"))}</small></span>
+                  <span className="task-dot" aria-hidden="true" />
+                </button>
+                <button
+                  type="button"
+                  className="session-delete-button"
+                  onClick={() => void deleteSession(session)}
+                  aria-label={t("sidebar.deleteSession")}
+                  title={t("sidebar.deleteSession")}
+                >
+                  <Trash2 size={14} />
+                </button>
+              </div>
             ))}
           </>}
         </div>
@@ -965,16 +1163,29 @@ export default function App() {
                 <div className="messages">
                   {conversationGroups.map((group) => (
                     group.type === "user"
-                      ? <UserMessage key={group.id} message={group.message} onPreview={setPreviewImage} />
+                      ? <UserMessage
+                          key={group.id}
+                          message={group.message}
+                          onPreview={setPreviewImage}
+                          onEdit={editMessage}
+                          editable={group.id === editableUserMessageId}
+                          editing={editingMessageId === group.message.id}
+                          disabled={running}
+                          editingText={editingText}
+                          editingSubmitting={editingSubmitting}
+                          onEditChange={setEditingText}
+                          onEditSubmit={() => void submitEditingMessage()}
+                          onEditCancel={cancelEditingMessage}
+                        />
                       : <AssistantTurn
                           key={group.id}
                           messages={group.messages}
                           active={group.id === activeAssistantGroupId}
                           showReasoningProcess={showReasoningProcess}
-                          onPreviewFile={(filePath) => void openFilePreview(filePath)}
+                          onPreviewFile={handlePreviewFile}
                         />
                   ))}
-                  {running && !uiRequest && !activeAssistantHasWork && (
+                  {latestAssistantIsActive && !uiRequest && !activeAssistantHasWork && (
                     <div className="work-log active" role="status" aria-live="polite">
                       <div className="work-log-summary work-log-status">
                         <LoaderCircle className="spin work-log-spinner" size={14} aria-hidden="true" />
@@ -986,8 +1197,14 @@ export default function App() {
                     <InlineExtensionRequest
                       key={uiRequest.id}
                       request={uiRequest}
-                      onDone={() => setUiRequest(undefined)}
-                      onError={(message) => setToast({ message, type: "error" })}
+                      onDone={() => {
+                        setUiRequest(undefined);
+                        setResumingUiRequest(true);
+                      }}
+                      onError={(message) => {
+                        setResumingUiRequest(false);
+                        setToast({ message, type: "error" });
+                      }}
                     />
                   )}
                 </div>
@@ -1324,30 +1541,154 @@ function EmptyState({ workspace, onSuggest }: { workspace?: string; onSuggest(va
   );
 }
 
-function UserMessage({ message, onPreview }: { message: ChatMessage; onPreview(image: PreviewImage): void }) {
+const UserMessage = memo(function UserMessage({
+  message,
+  onPreview,
+  onEdit,
+  editable,
+  editing,
+  disabled,
+  editingText,
+  editingSubmitting,
+  onEditChange,
+  onEditSubmit,
+  onEditCancel,
+}: {
+  message: ChatMessage;
+  onPreview(image: PreviewImage): void;
+  onEdit(message: ChatMessage): void;
+  editable: boolean;
+  editing: boolean;
+  disabled: boolean;
+  editingText: string;
+  editingSubmitting: boolean;
+  onEditChange(value: string): void;
+  onEditSubmit(): void;
+  onEditCancel(): void;
+}) {
   const { t } = useI18n();
+  const [copied, setCopied] = useState(false);
+
+  const copyMessage = async () => {
+    if (!message.text) return;
+    try {
+      if (navigator.clipboard?.writeText) {
+        await navigator.clipboard.writeText(message.text);
+      } else {
+        const fallback = document.createElement("textarea");
+        fallback.value = message.text;
+        fallback.setAttribute("readonly", "true");
+        fallback.style.position = "fixed";
+        fallback.style.opacity = "0";
+        document.body.appendChild(fallback);
+        fallback.select();
+        document.execCommand("copy");
+        fallback.remove();
+      }
+      setCopied(true);
+      window.setTimeout(() => setCopied(false), 1_200);
+    } catch {
+      setCopied(false);
+    }
+  };
+
   return (
-    <div className={`user-message${message.images.length > 0 ? " has-images" : ""}`}>
-      {message.images.length > 0 && (
-        <div className={`message-images${message.images.length > 1 ? " multiple" : ""}`}>
-          {message.images.map((image, index) => (
-            <button
-              type="button"
-              className="message-image-button"
-              key={`${image.mimeType}-${index}`}
-              onClick={() => onPreview({ ...image, alt: t("composer.imageNumber", { number: index + 1 }) })}
-              aria-label={t("composer.previewImage")}
-            >
-              <img src={imageDataUrl(image)} alt={t("composer.imageNumber", { number: index + 1 })} />
-            </button>
-          ))}
+    <div className={`user-message-row${editing ? " is-editing" : ""}`}>
+      <div className={`user-message${message.images.length > 0 ? " has-images" : ""}${editing ? " is-editing" : ""}`}>
+        {message.images.length > 0 && (
+          <div className={`message-images${message.images.length > 1 ? " multiple" : ""}`}>
+            {message.images.map((image, index) => (
+              <button
+                type="button"
+                className="message-image-button"
+                key={`${image.mimeType}-${index}`}
+                onClick={() => onPreview({ ...image, alt: t("composer.imageNumber", { number: index + 1 }) })}
+                aria-label={t("composer.previewImage")}
+              >
+                <img src={imageDataUrl(image)} alt={t("composer.imageNumber", { number: index + 1 })} />
+              </button>
+            ))}
+          </div>
+        )}
+        {editing ? (
+          <textarea
+            className="user-message-editor"
+            value={editingText}
+            onChange={(event) => onEditChange(event.target.value)}
+            onKeyDown={(event) => {
+              if (event.key === "Escape") {
+                event.preventDefault();
+                onEditCancel();
+              } else if (event.key === "Enter" && !event.shiftKey && !event.nativeEvent.isComposing) {
+                event.preventDefault();
+                onEditSubmit();
+              }
+            }}
+            autoFocus
+            rows={Math.min(8, Math.max(2, editingText.split("\n").length))}
+            disabled={editingSubmitting}
+            aria-label={t("conversation.editMessage")}
+          />
+        ) : message.text ? <div className="user-message-text">{message.text}</div> : null}
+        {message.queued && <small>{t("status.queued")}</small>}
+      </div>
+      {(editable || message.text) && (
+        <div className="user-message-actions">
+          {editing ? (
+            <>
+              <button
+                type="button"
+                className="message-action-button message-cancel-button"
+                onClick={onEditCancel}
+                disabled={editingSubmitting}
+                title={t("common.cancel")}
+                aria-label={t("common.cancel")}
+              >
+                <X size={13} />
+              </button>
+              <button
+                type="button"
+                className="message-action-button message-submit-button"
+                onClick={onEditSubmit}
+                disabled={editingSubmitting || (!editingText.trim() && message.images.length === 0)}
+                title={t("composer.send")}
+                aria-label={t("composer.send")}
+              >
+                {editingSubmitting ? <LoaderCircle className="spin" size={13} /> : <ArrowUp size={13} />}
+              </button>
+            </>
+          ) : (
+            <>
+              {editable && (
+                <button
+                  type="button"
+                  className="message-action-button message-edit-button"
+                  onClick={() => onEdit(message)}
+                  disabled={disabled}
+                  title={t("conversation.editMessage")}
+                  aria-label={t("conversation.editMessage")}
+                >
+                  <Pencil size={13} />
+                </button>
+              )}
+              {message.text && (
+                <button
+                  type="button"
+                  className="message-action-button message-copy-button"
+                  onClick={() => void copyMessage()}
+                  title={copied ? t("conversation.messageCopied") : t("conversation.copyMessage")}
+                  aria-label={copied ? t("conversation.messageCopied") : t("conversation.copyMessage")}
+                >
+                  {copied ? <Check size={13} /> : <Copy size={13} />}
+                </button>
+              )}
+            </>
+          )}
         </div>
       )}
-      {message.text && <div className="user-message-text">{message.text}</div>}
-      {message.queued && <small>{t("status.queued")}</small>}
     </div>
   );
-}
+});
 
 function ImageLightbox({ image, onClose }: { image: PreviewImage; onClose(): void }) {
   const { t } = useI18n();
@@ -1373,7 +1714,7 @@ function ImageLightbox({ image, onClose }: { image: PreviewImage; onClose(): voi
   );
 }
 
-function AssistantTurn({
+const AssistantTurn = memo(function AssistantTurn({
   messages,
   active,
   showReasoningProcess,
@@ -1405,7 +1746,13 @@ function AssistantTurn({
       ))}
     </article>
   );
-}
+}, (previous, next) => (
+  previous.active === next.active
+  && previous.showReasoningProcess === next.showReasoningProcess
+  && previous.onPreviewFile === next.onPreviewFile
+  && previous.messages.length === next.messages.length
+  && previous.messages.every((message, index) => message === next.messages[index])
+));
 
 function MarkdownContent({ text, className = "markdown-body", onPreviewFile }: { text: string; className?: string; onPreviewFile?(filePath: string): void }) {
   return (
@@ -1441,7 +1788,8 @@ function WorkLog({
   const activity = getAssistantActivity(messages);
   const [open, setOpen] = useState(false);
   const [now, setNow] = useState(Date.now());
-  const expanded = active || open;
+  const latestWork = timeline.at(-1);
+  const latestWorkLabel = latestWorkSummary(latestWork, t);
 
   useEffect(() => {
     if (!active) return;
@@ -1450,19 +1798,19 @@ function WorkLog({
   }, [active]);
 
   const duration = workDuration(messages, active ? now : undefined);
+  const expanded = active || open;
   const latestWorkKey = timeline.at(-1)?.key;
   return (
     <section className={`work-log ${expanded ? "open" : ""} ${active ? "active" : "complete"}`}>
       <button
         className="work-log-summary"
         aria-expanded={expanded}
-        aria-disabled={active}
         onClick={() => { if (!active) setOpen((value) => !value); }}
       >
         {active && <LoaderCircle className="spin work-log-spinner" size={14} aria-hidden="true" />}
         <span aria-live="polite">
           {active
-            ? t(activity === "tool" ? "work.toolStatus" : "work.thinkingStatus")
+            ? latestWorkLabel ?? t(activity === "tool" ? "work.toolStatus" : "work.thinkingStatus")
             : failed
               ? t("work.processedErrors")
               : t("work.processed")}
@@ -1493,6 +1841,22 @@ function WorkLog({
   );
 }
 
+function latestWorkSummary(entry: TurnWorkEntry | undefined, t: Translator): string | undefined {
+  if (!entry) return undefined;
+  if (entry.item.type === "tool") {
+    const toolId = entry.item.toolId;
+    const tool = entry.message.tools.find((candidate) => candidate.id === toolId);
+    return tool ? toolDisplayTitle(tool, t) : t("work.toolStatus");
+  }
+
+  const lines = entry.item.text
+    .split(/\r?\n/)
+    .map((line) => line.trim().replace(/\s+/g, " "))
+    .filter(Boolean);
+  const lastLine = lines.at(-1);
+  return lastLine ? crop(lastLine, 120) : undefined;
+}
+
 function ReasoningBlock({ text, active, autoExpand }: { text: string; active: boolean; autoExpand: boolean }) {
   const { t } = useI18n();
   const [open, setOpen] = useState(active && autoExpand);
@@ -2090,6 +2454,36 @@ function CommandPalette({ onClose, onNew, onOpen, onSettings, onInspector }: { o
   return <div className="modal-backdrop command-backdrop" onMouseDown={(event) => { if (event.target === event.currentTarget) onClose(); }}><div className="command-palette"><label><Search size={17} /><input autoFocus value={query} onChange={(event) => setQuery(event.target.value)} placeholder={t("command.search")} /></label><div>{commands.map((command) => <button key={command.label} onClick={() => { command.run(); onClose(); }}><command.icon size={16} /><span>{command.label}</span><kbd>{command.keys}</kbd></button>)}</div></div></div>;
 }
 
+function SidebarSessionTitle({ children }: { children: string }) {
+  const viewportRef = useRef<HTMLSpanElement>(null);
+  const textRef = useRef<HTMLSpanElement>(null);
+  const [scrollDistance, setScrollDistance] = useState(0);
+
+  useEffect(() => {
+    const viewport = viewportRef.current;
+    const text = textRef.current;
+    if (!viewport || !text) return;
+    const measure = () => setScrollDistance(Math.max(0, text.scrollWidth - viewport.clientWidth));
+    measure();
+    if (typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver(measure);
+    observer.observe(viewport);
+    return () => observer.disconnect();
+  }, [children]);
+
+  return (
+    <span ref={viewportRef} className="session-title-viewport">
+      <span
+        ref={textRef}
+        className={`session-title-scroll${scrollDistance > 0 ? " is-overflowing" : ""}`}
+        style={{ "--session-title-distance": `${scrollDistance}px` } as CSSProperties}
+      >
+        {children}
+      </span>
+    </span>
+  );
+}
+
 function SessionSearchDialog({
   sessions,
   workspaces,
@@ -2610,6 +3004,10 @@ function imageDataUrl(image: ChatImage): string {
   return image.data.startsWith("data:") ? image.data : `data:${image.mimeType};base64,${image.data}`;
 }
 
+function sameStringArray(left: string[], right: string[]): boolean {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
 type Translator = ReturnType<typeof useI18n>["t"];
 
 function permissionLabel(value: PermissionMode, t: Translator): string {
diff --git a/apps/desktop/src/renderer/lib/conversation.test.ts b/apps/desktop/src/renderer/lib/conversation.test.ts
index 1f108aa..c9028b7 100644
--- a/apps/desktop/src/renderer/lib/conversation.test.ts
+++ b/apps/desktop/src/renderer/lib/conversation.test.ts
@@ -1,7 +1,21 @@
 import { describe, expect, it } from "vitest";
-import { applyAgentEvent, getAssistantActivity, groupConversation, normalizeMessages, optimisticUserMessage, splitAssistantTurn } from "./conversation";
+import { applyAgentEvent, coalesceStreamingAgentEvents, getAssistantActivity, groupConversation, isAssistantTurnActive, normalizeMessages, optimisticUserMessage, splitAssistantTurn } from "./conversation";
 
 describe("conversation events", () => {
+  it("coalesces high-frequency streaming updates by payload key", () => {
+    const firstMessageUpdate = { type: "message_update", message: { role: "assistant", content: [{ type: "text", text: "A" }] } };
+    const secondMessageUpdate = { type: "message_update", message: { role: "assistant", content: [{ type: "text", text: "AB" }] } };
+    const firstToolUpdate = { type: "tool_execution_update", toolCallId: "tool-1", partialResult: "A" };
+    const secondToolUpdate = { type: "tool_execution_update", toolCallId: "tool-1", partialResult: "AB" };
+
+    expect(coalesceStreamingAgentEvents([
+      firstMessageUpdate,
+      firstToolUpdate,
+      secondMessageUpdate,
+      secondToolUpdate,
+    ])).toEqual([secondMessageUpdate, secondToolUpdate]);
+  });
+
   it("normalizes assistant text, thinking, and tool calls", () => {
     const messages = normalizeMessages([
       {
@@ -102,6 +116,19 @@ describe("conversation events", () => {
     expect(getAssistantActivity(messages)).toBe("thinking");
   });
 
+  it("does not treat a settled assistant snapshot as active work", () => {
+    const settled = normalizeMessages([{ role: "assistant", content: [{ type: "text", text: "Previous answer" }] }]);
+    expect(isAssistantTurnActive(settled)).toBe(false);
+
+    const runningTool = applyAgentEvent([], {
+      type: "tool_execution_start",
+      toolCallId: "call-1",
+      toolName: "exec_command",
+      args: { cmd: "rg --files" },
+    });
+    expect(isAssistantTurnActive(runningTool)).toBe(true);
+  });
+
   it("keeps reasoning and tools in their original content order", () => {
     const messages = normalizeMessages([{
       role: "assistant",
diff --git a/apps/desktop/src/renderer/lib/conversation.ts b/apps/desktop/src/renderer/lib/conversation.ts
index b9d1c43..89b969b 100644
--- a/apps/desktop/src/renderer/lib/conversation.ts
+++ b/apps/desktop/src/renderer/lib/conversation.ts
@@ -129,6 +129,41 @@ export function getAssistantActivity(messages: ChatMessage[]): AssistantActivity
     : "thinking";
 }
 
+export function isAssistantTurnActive(messages: ChatMessage[]): boolean {
+  return messages.some((message) => (
+    message.streaming === true || message.tools.some((tool) => tool.status === "running")
+  ));
+}
+
+export function isStreamingAgentEvent(event: AgentEvent): boolean {
+  return event.type === "message_update" || event.type === "tool_execution_update";
+}
+
+/** Keep only the latest payload for high-frequency streaming updates in a frame. */
+export function coalesceStreamingAgentEvents(events: AgentEvent[]): AgentEvent[] {
+  if (events.length < 2) return events;
+  const result: AgentEvent[] = [];
+  for (const event of events) {
+    const key = streamingEventKey(event);
+    if (key) {
+      for (let index = result.length - 1; index >= 0; index -= 1) {
+        if (streamingEventKey(result[index]!) === key) {
+          result.splice(index, 1);
+          break;
+        }
+      }
+    }
+    result.push(event);
+  }
+  return result;
+}
+
+function streamingEventKey(event: AgentEvent): string | undefined {
+  if (event.type === "message_update") return "message_update";
+  if (event.type !== "tool_execution_update" || typeof event.toolCallId !== "string") return undefined;
+  return `tool_execution_update:${event.toolCallId}`;
+}
+
 export function applyAgentEvent(messages: ChatMessage[], event: AgentEvent): ChatMessage[] {
   if (event.type === "message_start" || event.type === "message_update" || event.type === "message_end") {
     const raw = isRecord(event.message) ? event.message : undefined;
diff --git a/apps/desktop/src/renderer/lib/i18n.tsx b/apps/desktop/src/renderer/lib/i18n.tsx
index dc92058..d2f780c 100644
--- a/apps/desktop/src/renderer/lib/i18n.tsx
+++ b/apps/desktop/src/renderer/lib/i18n.tsx
@@ -55,6 +55,9 @@ const en = {
   "composer.send": "Send",
   "composer.sendOrStop": "Send instructions or stop",
   "composer.uploadFile": "Upload file",
+  "conversation.copyMessage": "Copy message",
+  "conversation.editMessage": "Edit and resend",
+  "conversation.messageCopied": "Copied",
   "context.cache": "Cache",
   "context.cacheRead": "Read",
   "context.cacheWrite": "Write",
@@ -217,8 +220,11 @@ const en = {
   "settings.website": "Website",
   "settings.workspaceWrite": "Workspace write",
   "sidebar.commands": "Commands",
+  "sidebar.confirmDeleteSession": "Delete \"{title}\" permanently?",
+  "sidebar.deleteSession": "Delete conversation",
   "sidebar.empty": "Your workspace threads appear here.",
   "sidebar.hide": "Hide sidebar",
+  "sidebar.newProjectThread": "New task in {project}",
   "sidebar.newThread": "New task",
   "sidebar.noProjectTasks": "No tasks in this project yet.",
   "sidebar.noProjects": "Open a folder to add a project.",
@@ -234,6 +240,7 @@ const en = {
   "sidebar.show": "Show sidebar",
   "sidebar.threads": "Threads",
   "status.connectProvider": "Connect {provider} before starting a thread.",
+  "status.cannotDeleteWhileRunning": "Stop the current response before deleting this conversation.",
   "status.newThread": "New task",
   "status.noWorkspace": "No workspace",
   "status.now": "now",
@@ -320,6 +327,9 @@ const zhCN: Record<TranslationKey, string> = {
   "composer.send": "发送",
   "composer.sendOrStop": "发送说明或停止",
   "composer.uploadFile": "上传文件",
+  "conversation.copyMessage": "复制消息",
+  "conversation.editMessage": "编辑并重新发送",
+  "conversation.messageCopied": "已复制",
   "context.cache": "缓存率",
   "context.cacheRead": "读取",
   "context.cacheWrite": "写入",
@@ -482,8 +492,11 @@ const zhCN: Record<TranslationKey, string> = {
   "settings.website": "官网",
   "settings.workspaceWrite": "工作区可写",
   "sidebar.commands": "命令",
+  "sidebar.confirmDeleteSession": "确定要永久删除“{title}”吗？",
+  "sidebar.deleteSession": "删除对话",
   "sidebar.empty": "工作区中的对话会显示在这里。",
   "sidebar.hide": "隐藏侧栏",
+  "sidebar.newProjectThread": "在 {project} 中新建任务",
   "sidebar.newThread": "新建任务",
   "sidebar.noProjectTasks": "这个项目还没有任务。",
   "sidebar.noProjects": "打开文件夹后，项目会显示在这里。",
@@ -499,6 +512,7 @@ const zhCN: Record<TranslationKey, string> = {
   "sidebar.show": "显示侧栏",
   "sidebar.threads": "对话",
   "status.connectProvider": "请先连接 {provider}，再开始新对话。",
+  "status.cannotDeleteWhileRunning": "当前回复进行中，请停止后再删除对话。",
   "status.newThread": "新任务",
   "status.noWorkspace": "未打开工作区",
   "status.now": "刚刚",
diff --git a/apps/desktop/src/renderer/preview-api.ts b/apps/desktop/src/renderer/preview-api.ts
index 9305475..3f0f827 100644
--- a/apps/desktop/src/renderer/preview-api.ts
+++ b/apps/desktop/src/renderer/preview-api.ts
@@ -97,6 +97,7 @@ export function createPreviewApi(): DesktopApi {
       pin: async () => true,
       archive: async () => undefined,
       unarchive: async () => undefined,
+      delete: async () => true,
     },
     auth: {
       status: async () => [{ id: "deepseek", name: "DeepSeek", configured: true, source: "stored", defaultModel: "deepseek-v4-flash" }],
diff --git a/apps/desktop/src/renderer/styles.css b/apps/desktop/src/renderer/styles.css
index 70f7431..681b6fe 100644
--- a/apps/desktop/src/renderer/styles.css
+++ b/apps/desktop/src/renderer/styles.css
@@ -64,30 +64,46 @@ kbd { margin-left: auto; color: var(--faint); font-family: -apple-system, sans-s
 .section-toggle[aria-expanded="true"] svg { transform: rotate(90deg); }
 .section-label.recent-label { margin-top: 14px; }
 .project-group { margin: 0; }
+.project-row-shell { position: relative; }
 .project-row { width: 100%; height: 30px; padding: 0 8px; border-radius: 6px; display: flex; align-items: center; gap: 8px; color: var(--tree-ink); text-align: left; }
 .project-row:hover { background: var(--tree-hover); }
 .project-row.active { background: var(--tree-selected); }
 .project-row svg { flex: none; stroke-width: 1.65; }
 .project-row strong { min-width: 0; overflow: hidden; white-space: nowrap; text-overflow: ellipsis; font-size: 13px; font-weight: 500; }
+.project-new-thread-button { width: 28px; height: 26px; position: absolute; z-index: 1; top: 50%; right: 3px; display: grid; place-items: center; border: 1px solid color-mix(in srgb, var(--line) 86%, transparent); border-radius: 6px; color: var(--ink); background: color-mix(in srgb, var(--sidebar) 96%, var(--surface)); -webkit-backdrop-filter: blur(9px) saturate(1.08); backdrop-filter: blur(9px) saturate(1.08); box-shadow: -8px 0 13px color-mix(in srgb, var(--sidebar) 68%, transparent), inset 1px 0 0 color-mix(in srgb, white 28%, transparent); opacity: 0; pointer-events: none; transform: translateY(-50%); transition: opacity .12s ease, color .12s ease, background-color .12s ease; }
+.project-row-shell:hover .project-new-thread-button, .project-row-shell:focus-within .project-new-thread-button { opacity: 1; pointer-events: auto; }
+.project-new-thread-button:hover, .project-new-thread-button:focus-visible { color: var(--ink); background: color-mix(in srgb, var(--hover) 82%, var(--sidebar)); }
 .project-task-list { margin: 1px 0 4px; display: flex; flex-direction: column; gap: 1px; }
-.project-task-row { width: 100%; height: 32px; padding: 0 8px 0 32px; border-radius: 6px; display: flex; align-items: center; color: var(--tree-ink); text-align: left; }
+.session-row { min-width: 0; position: relative; display: flex; align-items: center; border-radius: 6px; }
+.session-row:hover, .session-row:focus-within { background: var(--tree-hover); }
+.project-task-row { width: 100%; min-width: 0; height: 32px; padding: 0 8px; border-radius: 6px; display: flex; align-items: center; color: var(--tree-ink); text-align: left; }
 .project-task-row:hover { background: var(--tree-hover); }
 .project-task-row.active { background: var(--tree-selected); }
-.project-task-row > span:first-child { min-width: 0; flex: 1; overflow: hidden; white-space: nowrap; text-overflow: ellipsis; font-size: 13px; font-weight: 430; }
-.project-task-empty { padding: 4px 8px 6px 32px; color: var(--tree-muted); font-size: 12px; line-height: 1.45; }
-.project-task-more { width: 100%; height: 30px; padding: 0 8px 0 32px; border-radius: 6px; color: var(--tree-muted); font-size: 12px; text-align: left; }
+.session-title-viewport { min-width: 0; flex: 1; overflow: hidden; display: block; white-space: nowrap; }
+.session-title-scroll { display: inline-block; min-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.session-title-scroll.is-overflowing { text-overflow: clip; }
+.session-row:hover .session-title-scroll.is-overflowing, .session-row:focus-within .session-title-scroll.is-overflowing { animation: session-title-marquee 5.5s ease-in-out infinite alternate; }
+.session-delete-button { width: 38px; height: 30px; position: absolute; z-index: 1; top: 50%; right: 0; display: grid; place-items: center; border: 1px solid color-mix(in srgb, var(--line) 86%, transparent); border-right: 0; border-radius: 7px 0 0 7px; color: var(--ink); background: color-mix(in srgb, var(--sidebar) 96%, var(--surface)); -webkit-backdrop-filter: blur(9px) saturate(1.08); backdrop-filter: blur(9px) saturate(1.08); box-shadow: -10px 0 15px color-mix(in srgb, var(--sidebar) 68%, transparent), inset 1px 0 0 color-mix(in srgb, white 28%, transparent); opacity: 0; pointer-events: none; transform: translateY(-50%); transition: opacity .12s ease, color .12s ease, background-color .12s ease; }
+.session-row:hover .session-delete-button, .session-row:focus-within .session-delete-button { opacity: 1; pointer-events: auto; }
+.session-delete-button:hover, .session-delete-button:focus-visible { color: var(--ink); background: color-mix(in srgb, var(--hover) 82%, var(--sidebar)); }
+.project-task-empty { padding: 4px 8px 6px; color: var(--tree-muted); font-size: 12px; line-height: 1.45; }
+.project-task-more { width: 100%; height: 30px; padding: 0 8px; border-radius: 6px; color: var(--tree-muted); font-size: 12px; text-align: left; }
 .project-task-more:hover { background: var(--tree-hover); color: var(--tree-ink); }
-.thread-row { width: 100%; min-height: 34px; padding: 4px 7px; border-radius: 6px; display: flex; align-items: center; gap: 8px; color: var(--tree-ink); text-align: left; margin: 0; }
+.thread-row { width: 100%; min-width: 0; min-height: 34px; padding: 4px 7px; border-radius: 6px; display: flex; align-items: center; gap: 8px; color: var(--tree-ink); text-align: left; margin: 0; }
 .thread-row:hover { background: var(--tree-hover); }
 .thread-row.active { background: var(--tree-selected); }
 .thread-copy { flex: 1; min-width: 0; display: flex; align-items: baseline; gap: 7px; }
-.thread-copy strong { min-width: 0; flex: 1; font-size: 12.5px; font-weight: 480; overflow: hidden; white-space: nowrap; text-overflow: ellipsis; }
+.thread-copy .session-title-viewport { font-size: 12.5px; font-weight: 480; }
 .thread-copy small { color: var(--tree-muted); font-size: 10.5px; flex: none; }
 .thread-more { opacity: 0; }
 .thread-row:hover .thread-more { opacity: 1; }
 .recent-task-row { padding-left: 8px; }
 .task-dot { width: 6px; height: 6px; flex: none; border-radius: 50%; background: var(--focus); opacity: 0; box-shadow: 0 0 0 2px color-mix(in srgb, var(--focus) 10%, transparent); }
 .recent-task-row.active .task-dot { opacity: 1; }
+@keyframes session-title-marquee {
+  0%, 18% { transform: translateX(0); }
+  82%, 100% { transform: translateX(calc(var(--session-title-distance) * -1)); }
+}
 .sidebar-empty { padding: 8px; color: var(--tree-muted); font-size: 12px; line-height: 1.5; }
 .sidebar-footer { position: relative; border-top: 1px solid color-mix(in srgb, var(--line) 82%, transparent); padding: 7px 8px 9px; }
 .sidebar-account-button { width: 100%; height: 40px; display: flex; align-items: center; gap: 9px; padding: 0 8px; border-radius: 9px; color: var(--ink); text-align: left; }
@@ -154,7 +170,7 @@ kbd { margin-left: auto; color: var(--faint); font-family: -apple-system, sans-s
 .context-card-footer > div:last-child { align-items: flex-end; }
 .context-card-footer span { color: var(--faint); font-size: 9px; }
 .context-card-footer strong { max-width: 160px; overflow: hidden; font-size: 10.5px; font-weight: 580; text-overflow: ellipsis; white-space: nowrap; font-variant-numeric: tabular-nums; }
-.message-scroll { min-height: 0; flex: 1; overflow-x: hidden; overflow-y: auto; overscroll-behavior: contain; scroll-behavior: smooth; }
+.message-scroll { min-height: 0; flex: 1; overflow-x: hidden; overflow-y: auto; overscroll-behavior: contain; scroll-behavior: auto; }
 .messages { width: min(100%, 820px); padding: 50px 32px 165px; margin: 0 auto; }
 .context-card-visible .messages { width: min(calc(100% - 300px), 820px); margin-left: auto; margin-right: 300px; }
 .context-card-visible .composer-stack { width: min(calc(100% - 300px), 780px); margin-left: auto; margin-right: 300px; }
@@ -170,9 +186,25 @@ kbd { margin-left: auto; color: var(--faint); font-family: -apple-system, sans-s
 .suggestion-grid button { min-height: 72px; padding: 13px; display: flex; flex-direction: column; align-items: flex-start; justify-content: space-between; border: 1px solid var(--line); border-radius: 9px; background: color-mix(in srgb, var(--surface) 72%, transparent); color: var(--muted); text-align: left; }
 .suggestion-grid button:hover { background: var(--surface); color: var(--ink); border-color: color-mix(in srgb, var(--line) 65%, var(--ink)); }
 
-.user-message { width: fit-content; max-width: 80%; margin: 0 0 29px auto; padding: 10px 13px; border: 1px solid var(--line); border-radius: 13px 13px 4px 13px; background: var(--surface); line-height: 1.55; white-space: pre-wrap; box-shadow: 0 1px 1px rgba(30,30,27,.025); }
+.user-message-row { width: 100%; min-width: 0; display: flex; flex-direction: column; align-items: flex-end; gap: 4px; margin: 0 0 29px; }
+.user-message { width: fit-content; max-width: 80%; min-width: 0; margin: 0; padding: 10px 13px; border: 1px solid var(--line); border-radius: 13px 13px 4px 13px; background: var(--surface); line-height: 1.55; white-space: pre-wrap; box-shadow: 0 1px 1px rgba(30,30,27,.025); content-visibility: auto; contain-intrinsic-size: auto 64px; }
+.user-message-row .user-message { max-width: 80%; }
+.user-message-actions { display: flex; flex: none; align-items: center; gap: 4px; max-height: 0; overflow: hidden; opacity: 0; transform: translateY(-3px); pointer-events: none; transition: max-height .14s ease, opacity .14s ease, transform .14s ease; }
+.user-message-row:hover .user-message-actions, .user-message-row:focus-within .user-message-actions, .user-message-row.is-editing .user-message-actions { max-height: 30px; opacity: 1; transform: translateY(0); pointer-events: auto; }
+.message-action-button { width: 27px; height: 27px; display: grid; place-items: center; border-radius: 8px; color: var(--muted); background: color-mix(in srgb, var(--surface) 86%, var(--line)); }
+.message-action-button:hover:not(:disabled) { color: var(--ink); background: var(--hover); }
+.message-action-button:disabled { cursor: default; opacity: .7; }
+.user-message.is-editing { width: min(80%, 640px); min-width: 0; padding: 12px 13px; border-radius: 13px; white-space: normal; }
+.user-message-row .user-message.is-editing { max-width: min(80%, 640px); }
+.message-submit-button { color: var(--surface); background: var(--accent); }
+.message-submit-button:hover:not(:disabled) { color: var(--surface); background: color-mix(in srgb, var(--accent) 86%, white); }
+.message-copy-button { color: var(--muted); }
+.message-copy-button:hover:not(:disabled) { color: var(--ink); }
+.user-message-editor { display: block; width: 100%; min-width: 0; min-height: 52px; max-height: 220px; padding: 0; border: 0; outline: none; resize: none; overflow-y: auto; background: transparent; color: inherit; font: inherit; line-height: inherit; }
 .user-message small { display: block; color: var(--faint); margin-top: 5px; font-size: 10px; }
 .user-message.has-images { max-width: min(80%, 440px); padding: 6px; }
+.user-message-row .user-message.has-images { max-width: min(80%, 440px); }
+.user-message-row .user-message.has-images.is-editing { max-width: min(80%, 640px); padding: 8px 13px 8px 8px; }
 .user-message.has-images .user-message-text { padding: 5px 7px 3px; }
 .user-message.has-images small { padding: 0 7px 2px; }
 .message-images { display: grid; gap: 5px; }
@@ -183,20 +215,20 @@ kbd { margin-left: auto; color: var(--faint); font-family: -apple-system, sans-s
 .message-images.multiple { grid-template-columns: repeat(2, minmax(0, 1fr)); width: min(360px, 64vw); }
 .message-images.multiple .message-image-button { aspect-ratio: 4 / 3; }
 .message-images.multiple img { width: 100%; height: 100%; object-fit: cover; }
-.assistant-message { margin-bottom: 34px; line-height: 1.62; font-size: 14px; overflow-wrap: anywhere; }
+.assistant-message { margin-bottom: 34px; line-height: 1.62; font-size: 14px; overflow-wrap: anywhere; content-visibility: auto; contain-intrinsic-size: auto 180px; }
 .assistant-message:last-child { margin-bottom: 8px; }
 .assistant-response + .assistant-response { margin-top: 13px; }
 .work-log { margin: 0 0 17px; color: var(--muted); font-size: 12px; }
 .work-log-summary { width: 100%; min-height: 32px; display: flex; align-items: center; gap: 6px; padding: 2px 3px 9px; border-bottom: 1px solid var(--line); color: var(--muted); text-align: left; user-select: none; }
 .work-log-summary:hover { color: var(--ink); }
-.work-log-summary[aria-disabled="true"] { cursor: default; }
 .work-log-status { cursor: default; }
-.work-log-summary > span { font-size: 13px; font-weight: 570; }
+.work-log-summary > span { min-width: 0; flex: 1; overflow: hidden; font-size: 13px; font-weight: 570; text-overflow: ellipsis; white-space: nowrap; }
 .work-log-summary time { color: var(--faint); font-variant-numeric: tabular-nums; }
 .work-log-spinner { flex: none; margin-right: 1px; color: var(--focus); }
 .work-log-chevron { margin-left: 1px; transition: transform .16s ease; }
 .work-log.open .work-log-chevron { transform: rotate(180deg); }
-.work-log.active .work-log-summary > span { color: var(--ink); }
+.work-log.active .work-log-summary > span { color: var(--muted); font-weight: 450; opacity: .78; }
+.work-log.active .work-log-summary:hover > span { color: var(--ink); opacity: 1; }
 .work-log-content { padding: 8px 0 3px; animation: work-log-reveal .16s ease-out; }
 .work-timeline { display: flex; flex-direction: column; gap: 2px; }
 .work-text { padding: 4px 0 10px; color: var(--ink); font-size: 14px; line-height: 1.62; }
diff --git a/apps/desktop/src/shared/types.ts b/apps/desktop/src/shared/types.ts
index e0287fa..d44cfd0 100644
--- a/apps/desktop/src/shared/types.ts
+++ b/apps/desktop/src/shared/types.ts
@@ -211,6 +211,7 @@ export interface DesktopApi {
     pin(id: string, pinned: boolean): Promise<boolean>;
     archive(id: string): Promise<SessionSummary | undefined>;
     unarchive(id: string): Promise<SessionSummary | undefined>;
+    delete(id: string): Promise<boolean>;
   };
   auth: {
     status(): Promise<ProviderStatus[]>;
diff --git a/packages/core/src/cli-runtime.ts b/packages/core/src/cli-runtime.ts
index de34aba..07e142c 100644
--- a/packages/core/src/cli-runtime.ts
+++ b/packages/core/src/cli-runtime.ts
@@ -1,3 +1,7 @@
+import fs from "node:fs/promises";
+import { spawn } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
 import process from "node:process";
 import pc from "picocolors";
 import { ensureFirstRunAuth, runAuthCommand } from "./auth.js";
@@ -7,6 +11,17 @@ import { initializeDSCodeHome } from "./home.js";
 import { installPiLoginSecretMask } from "./pi-login-mask.js";
 import { installPiMarkdownCodeBlocks } from "./pi-markdown.js";
 import { parseSupportedProviderId, type SupportedProviderId } from "./providers.js";
+import {
+  evaluateReplay,
+  formatEvaluationResult,
+  type EvaluationOptions,
+} from "./evaluation.js";
+import { readAgentFixtureFile } from "./fixture.js";
+import {
+  compareTraceReports,
+  formatReplayReport,
+  readTraceFile,
+} from "./replay.js";
 import { parseRuntimeArgs, printDSCodeHelp } from "./runtime-options.js";
 import { installDSCodeRuntimeBranding } from "./runtime-branding.js";
 import { ensureDSCodeUiDefaults } from "./ui-defaults.js";
@@ -23,6 +38,11 @@ export async function runDSCode(argv: string[]): Promise<void> {
     runWindowsSandboxLifecycle(windowsSandboxCommand);
     return;
   }
+  const traceCommand = parseTraceCommand(argv);
+  if (traceCommand) {
+    await runTraceCommand(traceCommand);
+    return;
+  }
   const parsed = parseRuntimeArgs(argv);
   if (parsed.help) {
     printDSCodeHelp();
@@ -61,6 +81,242 @@ export async function runDSCode(argv: string[]): Promise<void> {
   });
 }
 
+interface TraceCommand {
+  command: "replay" | "evaluate";
+  input: string;
+  compare?: string;
+  execute?: boolean;
+  prompt?: string;
+  json: boolean;
+  evaluation: EvaluationOptions;
+}
+
+function parseTraceCommand(argv: string[]): TraceCommand | undefined {
+  const command = argv[0];
+  if (command !== "replay" && command !== "evaluate" && command !== "eval") return undefined;
+  const paths: string[] = [];
+  let json = false;
+  let compare = false;
+  let execute = false;
+  let prompt: string | undefined;
+  const evaluation: EvaluationOptions = {};
+  for (let index = 1; index < argv.length; index += 1) {
+    const argument = argv[index]!;
+    if (argument === "--json") {
+      json = true;
+      continue;
+    }
+    if (argument === "--compare") {
+      compare = true;
+      continue;
+    }
+    const [flag, inlineValue] = splitTraceFlag(argument);
+    if (flag === "--execute") {
+      if (command !== "replay") {
+        throw new Error("--execute is only supported by replay");
+      }
+      const value = inlineValue ?? argv[++index];
+      if (!value) throw new Error("--execute requires a fixture file");
+      execute = true;
+      paths.push(value);
+      continue;
+    }
+    if (flag === "--prompt") {
+      prompt = inlineValue ?? argv[++index];
+      if (!prompt) throw new Error("--prompt requires a value");
+      continue;
+    }
+    if (
+      flag === "--max-tool-calls" ||
+      flag === "--max-duration-ms" ||
+      flag === "--max-total-tokens" ||
+      flag === "--max-cost"
+    ) {
+      const value = inlineValue ?? argv[++index];
+      if (!value) throw new Error(`${flag} requires a value`);
+      const parsed = Number(value);
+      if (!Number.isFinite(parsed) || parsed < 0) throw new Error(`${flag} requires a non-negative number`);
+      if (flag === "--max-tool-calls") evaluation.maxToolCalls = parsed;
+      if (flag === "--max-duration-ms") evaluation.maxDurationMs = parsed;
+      if (flag === "--max-total-tokens") evaluation.maxTotalTokens = parsed;
+      if (flag === "--max-cost") evaluation.maxCost = parsed;
+      continue;
+    }
+    if (argument === "--allow-errors") {
+      evaluation.failOnErrors = false;
+      continue;
+    }
+    if (argument.startsWith("-")) throw new Error(`unknown trace option: ${argument}`);
+    paths.push(argument);
+  }
+  if (compare) {
+    if (execute) throw new Error("replay --execute cannot be combined with --compare");
+    if (paths.length !== 2) throw new Error("replay --compare requires baseline and candidate trace files");
+    return { command: "replay", input: paths[0]!, compare: paths[1]!, json, evaluation };
+  }
+  if (paths.length !== 1) throw new Error(`${command} requires one trace file`);
+  return {
+    command: command === "eval" ? "evaluate" : command,
+    input: paths[0]!,
+    ...(execute ? { execute } : {}),
+    ...(prompt ? { prompt } : {}),
+    json,
+    evaluation,
+  };
+}
+
+async function runTraceCommand(command: TraceCommand): Promise<void> {
+  if (command.execute) {
+    await runFixtureReplayCommand(command);
+    return;
+  }
+  const report = await readTraceFile(command.input);
+  if (command.compare) {
+    const comparison = compareTraceReports(report, await readTraceFile(command.compare));
+    process.stdout.write(
+      command.json
+        ? `${JSON.stringify(comparison, null, 2)}\n`
+        : `${formatReplayReport(comparison.baseline)}\n\nCandidate\n${formatReplayReport(comparison.candidate)}\n\nDifferences\n${comparison.differences.join("\n") || "none"}\n`,
+    );
+    if (!comparison.candidate.valid) process.exitCode = 1;
+    return;
+  }
+  if (command.command === "replay") {
+    process.stdout.write(`${formatReplayReport(report, command.json)}\n`);
+    if (!report.valid) process.exitCode = 1;
+    return;
+  }
+  const result = evaluateReplay(report, command.evaluation);
+  process.stdout.write(`${formatEvaluationResult(result, command.json)}\n`);
+  if (!result.passed) process.exitCode = 1;
+}
+
+async function runFixtureReplayCommand(command: TraceCommand): Promise<void> {
+  const fixturePath = path.resolve(command.input);
+  const fixture = await readAgentFixtureFile(fixturePath);
+  if (fixture.provider !== "deepseek") {
+    throw new Error(`Fixture provider "${fixture.provider}" is not supported by this runtime yet`);
+  }
+  const runDirectory = await fs.mkdtemp(path.join(os.tmpdir(), "dscode-fixture-replay-"));
+  const traceDirectory = path.join(runDirectory, "traces");
+  const homeDirectory = path.join(runDirectory, "home");
+  try {
+    const nestedExitCode = await runFixtureRuntime({
+      fixturePath,
+      fixtureModel: fixture.model,
+      prompt: command.prompt ?? "Replay fixture",
+      homeDirectory,
+      traceDirectory,
+    });
+    const traceFiles = (await fs.readdir(traceDirectory))
+      .filter((file) => file.endsWith(".jsonl"))
+      .sort();
+    if (traceFiles.length === 0) {
+      throw new Error("Fixture replay completed without producing a trace");
+    }
+    const report = await readTraceFile(path.join(traceDirectory, traceFiles[traceFiles.length - 1]!));
+    const result = evaluateReplay(
+      report,
+      { ...(fixture.evaluation ?? {}), ...command.evaluation },
+    );
+    const assertionViolations = fixtureAssertionViolations(fixture, report);
+    result.violations.push(...assertionViolations);
+    if (nestedExitCode !== 0 && report.finalStatus === "completed") {
+      result.violations.push(`fixture runtime exited with code ${nestedExitCode}`);
+    }
+    result.passed = result.violations.length === 0;
+    process.stdout.write(`${formatEvaluationResult(result, command.json)}\n`);
+    process.exitCode = result.passed ? 0 : 1;
+  } finally {
+    await fs.rm(runDirectory, { recursive: true, force: true });
+  }
+}
+
+interface FixtureRuntimeOptions {
+  fixturePath: string;
+  fixtureModel: string;
+  prompt: string;
+  homeDirectory: string;
+  traceDirectory: string;
+}
+
+async function runFixtureRuntime(options: FixtureRuntimeOptions): Promise<number> {
+  const invocation = currentCliInvocation();
+  const child = spawn(
+    invocation.command,
+    [
+      ...invocation.args,
+      "--provider",
+      "deepseek",
+      "--model",
+      options.fixtureModel,
+      "--permission",
+      "full",
+      "--mode",
+      "json",
+      "--print",
+      "--no-session",
+      "--no-approve",
+      options.prompt,
+    ],
+    {
+      env: {
+        ...process.env,
+        DSCODE_HOME: options.homeDirectory,
+        DSCODE_SESSIONS_DIR: path.join(options.homeDirectory, "sessions"),
+        DSCODE_TRACE_DIR: options.traceDirectory,
+        DSCODE_TRACE: "1",
+        DSCODE_FIXTURE_PATH: options.fixturePath,
+        DEEPSEEK_API_KEY: "dscode-fixture",
+        PI_TELEMETRY: "0",
+        PI_SKIP_VERSION_CHECK: "1",
+      },
+      stdio: "ignore",
+    },
+  );
+  return await new Promise<number>((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code) => resolve(code ?? 1));
+  });
+}
+
+function currentCliInvocation(): { command: string; args: string[] } {
+  const [nodePath, launcher, source] = process.argv;
+  if (!nodePath || !launcher) throw new Error("Could not determine the current DSCode CLI invocation");
+  if (source?.endsWith(".ts")) {
+    return { command: nodePath, args: [launcher, source] };
+  }
+  return { command: nodePath, args: [launcher] };
+}
+
+function fixtureAssertionViolations(
+  fixture: Awaited<ReturnType<typeof readAgentFixtureFile>>,
+  report: Awaited<ReturnType<typeof readTraceFile>>,
+): string[] {
+  const violations: string[] = [];
+  if (report.counts.modelResponses !== fixture.responses.length) {
+    violations.push(
+      `fixture responses consumed: ${report.counts.modelResponses} != ${fixture.responses.length}`,
+    );
+  }
+  const assertions = fixture.assertions;
+  if (!assertions) return violations;
+  if (assertions.finalStatus && report.finalStatus !== assertions.finalStatus) {
+    violations.push(`expected final status ${assertions.finalStatus}, got ${report.finalStatus ?? "missing"}`);
+  }
+  if (assertions.modelResponses !== undefined && report.counts.modelResponses !== assertions.modelResponses) {
+    violations.push(
+      `expected model responses ${assertions.modelResponses}, got ${report.counts.modelResponses}`,
+    );
+  }
+  if (assertions.toolNames && JSON.stringify(report.toolNames) !== JSON.stringify(assertions.toolNames)) {
+    violations.push(
+      `expected tool sequence ${JSON.stringify(assertions.toolNames)}, got ${JSON.stringify(report.toolNames)}`,
+    );
+  }
+  return violations;
+}
+
 /** Process-oriented wrapper used by the terminal and bundled RPC entry points. */
 export async function runDSCodeProcess(argv: string[]): Promise<void> {
   try {
@@ -84,6 +340,12 @@ interface AuthCommand {
   providerId?: SupportedProviderId;
 }
 
+function splitTraceFlag(argument: string): [string, string | undefined] {
+  if (!argument.startsWith("--") || !argument.includes("=")) return [argument, undefined];
+  const index = argument.indexOf("=");
+  return [argument.slice(0, index), argument.slice(index + 1)];
+}
+
 function parseAuthCommand(argv: string[]): AuthCommand | undefined {
   const command = argv[0];
   if (command === "login" || command === "logout") {
diff --git a/packages/core/src/dscode-extension.ts b/packages/core/src/dscode-extension.ts
index ed72374..ae01e6a 100644
--- a/packages/core/src/dscode-extension.ts
+++ b/packages/core/src/dscode-extension.ts
@@ -30,6 +30,18 @@ import { registerLocalImageInput } from "./image-input.js";
 import { partitionSessionFile } from "./home.js";
 import { ManagedProcessRegistry, type ManagedProcessResult } from "./managed-process.js";
 import { MCPManager } from "./mcp.js";
+import {
+  AgentFixtureRecorder,
+  AgentFixtureReplay,
+  readAgentFixtureFileSync,
+} from "./fixture.js";
+import {
+  AgentRuntimeTrace,
+  classifyHttpStatus,
+  summarizeContent,
+  summarizeValue,
+  usageFromPiUsage,
+} from "./observability.js";
 import { applyWorkspacePatch, type ApplyPatchResult } from "./patch.js";
 import {
   formatPlanForExecution,
@@ -43,6 +55,29 @@ import { discoverProjectCommands } from "./project-profile.js";
 import { registerDSCodeProjectTrust } from "./project-trust.js";
 import { defaultModelForProvider } from "./providers.js";
 import { composePersonalizedSystemPrompt, loadPersonalizationPrompt } from "./personalization.js";
+import {
+  classifyRoute,
+  createRoutePhaseState,
+  createRouteState,
+  formatRoutePhaseStatus,
+  formatRouteStatus,
+  isOpeningRouteTurn,
+  parseRouteSelection,
+  restoreRoutePhaseState,
+  restoreRouteState,
+  routeCommandUsage,
+  routePhaseTraceAttributes,
+  routeProfileLabel,
+  routeProfileShortLabel,
+  routeStateTraceAttributes,
+  routeSystemPrompt,
+  routeThinkingBoost,
+  ROUTE_PHASE_ENTRY,
+  ROUTE_STATE_ENTRY,
+  type RoutePhaseState,
+  type RouteState,
+  type RouteThinkingTarget,
+} from "./route-profile.js";
 import type { DSCodeRuntimeOptions } from "./runtime-options.js";
 import { executeSandboxedCommand, sandboxDescription } from "./sandbox.js";
 import { registerSessionCommands } from "./session-commands.js";
@@ -122,7 +157,12 @@ const applyPatchParameters = Type.Object({
   }),
 });
 
-export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExtension {
+export function createDSCodeExtension(inputOptions: DSCodeRuntimeOptions): InlineExtension {
+  // Keep the extension's provider and tool configuration stable for its lifetime.
+  const options = Object.freeze({
+    ...inputOptions,
+    activeTools: [...inputOptions.activeTools],
+  });
   return {
     name: "dscode",
     factory(pi) {
@@ -137,11 +177,26 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
       let toolsBeforePlan: string[] | undefined;
       let projectCommands: string[] = [];
       let lastAgentFailed = false;
+      let traceErrorRecorded = false;
       let sessionPartition = Promise.resolve();
       let planState: PlanState | undefined;
       let lastOfferedPlanRevision = 0;
+      let routeState: RouteState | undefined;
+      let routePhaseState: RoutePhaseState | undefined;
+      let effortManuallyChanged = options.effortExplicit;
       const access = new SessionAccessController(options.sandbox, options.network);
+      const trace = new AgentRuntimeTrace();
+      const fixturePath = process.env.DSCODE_FIXTURE_PATH?.trim();
+      const fixture = fixturePath ? readAgentFixtureFileSync(fixturePath) : undefined;
+      const fixtureReplay = fixture ? new AgentFixtureReplay(fixture) : undefined;
+      const fixtureRecorder = options.fixtureCapturePath
+        ? new AgentFixtureRecorder(options.fixtureCapturePath, options.providerId, options.modelId)
+        : undefined;
+      const pendingModelSpans: string[] = [];
+      const pendingCompactionSpans: string[] = [];
+      let traceSequence = 0;
       const effectiveAccess = (): EffectiveAccess => access.effective(permission);
+      const nextTraceSpan = (kind: string): string => `${kind}:${++traceSequence}`;
 
       const queueSessionPartition = (ctx: ExtensionContext): Promise<void> => {
         const sessionFile = ctx.sessionManager.getSessionFile();
@@ -157,7 +212,8 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
 
       const updateStatus = (ctx: ExtensionContext): void => {
         const currentAccess = effectiveAccess();
-        const status = `DSCode · ${permission} · ${sandboxDescription({
+        const routeSegment = routeState ? ` · ${routeProfileShortLabel(routeState.profile)}` : "";
+        const status = `DSCode · ${permission}${routeSegment} · ${sandboxDescription({
           mode: currentAccess.sandbox,
           network: currentAccess.network,
         })}`;
@@ -171,7 +227,7 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
         ctx.ui.setWidget("dscode-plan", planWidgetLines(planState, ctx));
       };
 
-      registerDeepSeekProvider(pi, options);
+      registerDeepSeekProvider(pi, options, fixtureReplay);
       registerLocalImageInput(pi);
       registerNaturalExit(pi);
       registerSessionCommands(pi);
@@ -222,17 +278,124 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
         }
       };
 
+      const classifyCurrentRoute = (prompt: unknown, ctx: ExtensionContext): RouteState =>
+        classifyRoute({
+          prompt,
+          entries: ctx.sessionManager.getBranch(),
+          providerId: ctx.model?.provider ?? options.providerId,
+          modelId: ctx.model?.id ?? options.modelId,
+          harness: options.harness,
+          permission,
+          projectCommands,
+        });
+
+      const ensureRouteState = (prompt: unknown, ctx: ExtensionContext): RouteState => {
+        if (routeState) return routeState;
+        routeState = classifyCurrentRoute(prompt, ctx);
+        pi.appendEntry(ROUTE_STATE_ENTRY, routeState);
+        updateStatus(ctx);
+        return routeState;
+      };
+
+      const beginRouteTurn = (state: RouteState, openingTurn: boolean): RoutePhaseState => {
+        const turnsStarted = openingTurn
+          ? 1
+          : Math.max(1, routePhaseState?.turnsStarted ?? 1) + 1;
+        routePhaseState = createRoutePhaseState(state, turnsStarted);
+        pi.appendEntry(ROUTE_PHASE_ENTRY, routePhaseState);
+        return routePhaseState;
+      };
+
+      const resetRoutePhase = (state: RouteState): void => {
+        routePhaseState = createRoutePhaseState(state, 0);
+        pi.appendEntry(ROUTE_PHASE_ENTRY, routePhaseState);
+      };
+
+      const applyRouteThinkingBoost = (
+        state: RouteState,
+      ): RouteThinkingTarget | undefined => {
+        if (effortManuallyChanged) return undefined;
+        const current = pi.getThinkingLevel();
+        const boosted = routeThinkingBoost(current, state.profile);
+        if (!boosted || current === boosted) return undefined;
+        pi.setThinkingLevel(boosted as ThinkingLevel);
+        return boosted;
+      };
+
       pi.on("before_provider_request", (event, ctx) => {
+        const spanId = nextTraceSpan("model");
+        pendingModelSpans.push(spanId);
+        const routeAttributes = routeState ? routeStateTraceAttributes(routeState) : undefined;
+        trace.record({
+          type: "model_request",
+          spanId,
+          status: "started",
+          provider: ctx.model?.provider ?? options.providerId,
+          model: ctx.model?.id ?? options.modelId,
+          input: summarizeValue(event.payload),
+          ...(routeAttributes
+            ? {
+                attributes: {
+                  ...routeAttributes,
+                  ...routePhaseTraceAttributes(routePhaseState),
+                  routeThinkingLevel: pi.getThinkingLevel(),
+                },
+              }
+            : {}),
+        });
         if (ctx.model?.provider !== "deepseek" || options.transport !== "responses") return;
         return optimizeDeepSeekResponsesPayload(event.payload, { webSearch: options.webSearch });
       });
 
+      pi.on("after_provider_response", (event, ctx) => {
+        const spanId = pendingModelSpans[0] ?? nextTraceSpan("model-response");
+        const failed = event.status >= 400;
+        trace.record({
+          type: "provider_response",
+          spanId,
+          status: failed ? "failed" : "completed",
+          provider: ctx.model?.provider ?? options.providerId,
+          model: ctx.model?.id ?? options.modelId,
+          attributes: {
+            httpStatus: event.status,
+            responseHeaderCount: Object.keys(event.headers).length,
+          },
+        });
+        if (failed) {
+          lastAgentFailed = true;
+          pendingModelSpans.shift();
+          if (!traceErrorRecorded) {
+            traceErrorRecorded = true;
+            trace.recordError(
+              nextTraceSpan("error"),
+              classifyHttpStatus(event.status),
+              "provider response failed",
+              { httpStatus: event.status },
+            );
+          }
+        }
+      });
+
       pi.on("session_start", async (_event, ctx) => {
+        trace.setSession(ctx.sessionManager.getSessionId());
         checkpoints.length = 0;
         undone.clear();
+        effortManuallyChanged = options.effortExplicit;
         projectCommands = await discoverProjectCommands(ctx.cwd);
-        restoreCheckpointState(ctx.sessionManager.getBranch(), checkpoints, undone);
-        planState = restorePlanState(ctx.sessionManager.getBranch());
+        const branch = ctx.sessionManager.getBranch();
+        restoreCheckpointState(branch, checkpoints, undone);
+        planState = restorePlanState(branch);
+        routeState = restoreRouteState(branch);
+        routePhaseState = restoreRoutePhaseState(branch);
+        if (
+          options.route !== "auto" &&
+          (routeState?.profile !== options.route || routeState.source !== "config")
+        ) {
+          routeState = createRouteState(options.route, "config", "configured route override", 1);
+          pi.appendEntry(ROUTE_STATE_ENTRY, routeState);
+          resetRoutePhase(routeState);
+        }
+        if (routeState) applyRouteThinkingBoost(routeState);
         lastOfferedPlanRevision = planState?.revision ?? 0;
         updateStatus(ctx);
         ctx.ui.setHiddenThinkingLabel(
@@ -265,22 +428,58 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
       });
 
       pi.on("agent_settled", async (_event, ctx) => {
+        trace.endRun(lastAgentFailed ? "failed" : "completed");
+        await fixtureRecorder?.finish();
+        await trace.flush();
         await queueSessionPartition(ctx);
       });
 
       pi.on("session_shutdown", async (_event, ctx) => {
+        trace.shutdown("cancelled");
+        await fixtureRecorder?.finish();
+        await trace.flush();
         await queueSessionPartition(ctx);
         processes.dispose();
         await mcp.close();
       });
 
-      pi.on("before_agent_start", async (event) => {
+      pi.on("before_agent_start", async (event, ctx) => {
         lastAgentFailed = false;
+        traceErrorRecorded = false;
+        pendingModelSpans.length = 0;
+        const traceId = trace.startRun({
+          sessionId: ctx.sessionManager.getSessionId(),
+          provider: options.providerId,
+          model: options.modelId,
+        });
+        const selectedRoute = ensureRouteState(event.prompt, ctx);
+        const openingRouteTurn = isOpeningRouteTurn(selectedRoute, routePhaseState);
+        const currentRoutePhase = beginRouteTurn(selectedRoute, openingRouteTurn);
+        const boostedThinking = applyRouteThinkingBoost(selectedRoute);
+        trace.record({
+          type: "agent_start",
+          spanId: `agent:${traceId}`,
+          status: "started",
+          provider: ctx.model?.provider ?? options.providerId,
+          model: ctx.model?.id ?? options.modelId,
+          input: summarizeValue(event.prompt),
+          attributes: {
+            attachedImageCount: event.images?.length ?? 0,
+            ...routeStateTraceAttributes(selectedRoute),
+            ...routePhaseTraceAttributes(currentRoutePhase),
+            routeOpeningTurn: openingRouteTurn,
+            routeThinkingLevel: pi.getThinkingLevel(),
+            routeThinkingBoosted: Boolean(boostedThinking),
+          },
+        });
         const currentAccess = effectiveAccess();
         const personalizationPrompt = await loadPersonalizationPrompt(options.personalizationFile);
         const systemPrompt = composePersonalizedSystemPrompt(
           event.systemPrompt,
-          engineeringInstructions(projectCommands, currentAccess),
+          [
+            engineeringInstructions(projectCommands, currentAccess),
+            routeSystemPrompt(selectedRoute, { openingTurn: openingRouteTurn }),
+          ].join("\n\n"),
           personalizationPrompt,
         );
         if (permission !== "plan") return { systemPrompt };
@@ -302,25 +501,63 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
       });
 
       pi.on("tool_call", async (event, ctx) => {
+        trace.record({
+          type: "tool_call",
+          spanId: `tool:${event.toolCallId}`,
+          status: "started",
+          toolName: event.toolName,
+          toolCallId: event.toolCallId,
+          input: summarizeValue(event.input),
+          attributes: { inputKeyCount: Object.keys(event.input).length },
+        });
+        const blockTool = (reason: string, code = "policy") => {
+          trace.record({
+            type: "approval",
+            spanId: `approval:${event.toolCallId}`,
+            status: "failed",
+            toolName: event.toolName,
+            toolCallId: event.toolCallId,
+            attributes: { decision: "denied", code },
+          });
+          trace.record({
+            type: "tool_result",
+            spanId: `tool:${event.toolCallId}`,
+            status: "failed",
+            toolName: event.toolName,
+            toolCallId: event.toolCallId,
+            error: { code, message: "tool execution blocked" },
+            output: summarizeValue(reason),
+          });
+          return { block: true, reason };
+        };
+        const recordApproval = (decision: "approved" | "denied", code = "approval") => {
+          trace.record({
+            type: "approval",
+            spanId: `approval:${event.toolCallId}`,
+            status: decision === "approved" ? "completed" : "failed",
+            toolName: event.toolName,
+            toolCallId: event.toolCallId,
+            attributes: { decision, code },
+          });
+        };
         if (
           event.toolName === "bash" ||
           event.toolName === "run_command" ||
           event.toolName === "edit" ||
           event.toolName === "write"
         ) {
-          return {
-            block: true,
-            reason:
-              event.toolName === "bash" || event.toolName === "run_command"
-                ? "This shell tool bypasses DSCode's managed OS sandbox. Use exec_command instead."
-                : "This write tool bypasses DSCode checkpoints. Use apply_patch instead.",
-          };
+          return blockTool(
+            event.toolName === "bash" || event.toolName === "run_command"
+              ? "This shell tool bypasses DSCode's managed OS sandbox. Use exec_command instead."
+              : "This write tool bypasses DSCode checkpoints. Use apply_patch instead.",
+            "bypass",
+          );
         }
         if (permission === "plan" && !planAllowedTools.has(event.toolName)) {
-          return {
-            block: true,
-            reason: `Plan mode does not allow ${event.toolName}. Run /plan to leave plan mode.`,
-          };
+          return blockTool(
+            `Plan mode does not allow ${event.toolName}. Run /plan to leave plan mode.`,
+            "plan_mode",
+          );
         }
         const externalMcp = event.toolName.startsWith("mcp__");
         const command =
@@ -331,10 +568,10 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
             : undefined;
         const dangerousCommand = command !== undefined && classifyCommand(command) === "dangerous";
         if (permission === "plan" && dangerousCommand) {
-          return {
-            block: true,
-            reason: "Plan mode blocks destructive commands. Leave plan mode before running this command.",
-          };
+          return blockTool(
+            "Plan mode blocks destructive commands. Leave plan mode before running this command.",
+            "dangerous_command",
+          );
         }
         const needsApproval =
           permission === "ask" ||
@@ -359,18 +596,18 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
           return;
         }
         if (!ctx.hasUI) {
-          return {
-            block: true,
-            reason:
-              "This action requires an interactive approval UI. Use --permission full for an explicitly trusted non-interactive run.",
-          };
+          return blockTool(
+            "This action requires an interactive approval UI. Use --permission full for an explicitly trusted non-interactive run.",
+            "non_interactive",
+          );
         }
         if (dangerousCommand) {
           const approved = await ctx.ui.confirm(
             "Run destructive command?",
             `${command}\n\nThis may delete data or alter system/process state.`,
           );
-          if (!approved) return { block: true, reason: "Destructive command denied by user" };
+          if (!approved) return blockTool("Destructive command denied by user", "user_denied");
+          recordApproval("approved", "destructive_command");
         } else if (
           event.toolName === "apply_patch" &&
           isRecord(event.input) &&
@@ -378,17 +615,95 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
         ) {
           for (const section of patchApprovalSections(event.input.input)) {
             const approved = await ctx.ui.confirm(`Apply ${section.file}?`, section.patch);
-            if (!approved) return { block: true, reason: `Denied ${section.file} by user` };
+            if (!approved) return blockTool(`Denied ${section.file} by user`, "user_denied");
           }
+          recordApproval("approved", "patch");
         } else {
           const approved = await ctx.ui.confirm(
             `Allow ${event.toolName}?`,
             approvalSummary(event.toolName, event.input),
           );
-          if (!approved) return { block: true, reason: "Denied by user" };
+          if (!approved) return blockTool("Denied by user", "user_denied");
+          recordApproval("approved");
         }
       });
 
+      pi.on("tool_result", (event) => {
+        trace.record({
+          type: "tool_result",
+          spanId: `tool:${event.toolCallId}`,
+          status: event.isError ? "failed" : "completed",
+          toolName: event.toolName,
+          toolCallId: event.toolCallId,
+          content: summarizeContent(event.content),
+          output: summarizeValue(event.details),
+          ...(event.usage ? { usage: usageFromPiUsage(event.usage) } : {}),
+          ...(event.isError ? { error: { code: "tool", message: "tool execution failed" } } : {}),
+        });
+      });
+
+      pi.on("message_start", (event) => {
+        if (event.message.role !== "assistant" || pendingModelSpans.length > 0) return;
+        const spanId = nextTraceSpan("model");
+        pendingModelSpans.push(spanId);
+        trace.record({
+          type: "model_request",
+          spanId,
+          status: "started",
+          provider: event.message.provider,
+          model: event.message.model,
+        });
+      });
+
+      pi.on("turn_start", (event) => {
+        trace.record({
+          type: "turn_start",
+          spanId: `turn:${event.turnIndex}`,
+          turnId: `turn:${event.turnIndex}`,
+          status: "started",
+          attributes: { turnIndex: event.turnIndex },
+        });
+      });
+
+      pi.on("turn_end", (event) => {
+        trace.record({
+          type: "turn_end",
+          spanId: `turn:${event.turnIndex}`,
+          turnId: `turn:${event.turnIndex}`,
+          status: "completed",
+          attributes: { toolResultCount: event.toolResults.length },
+        });
+      });
+
+      pi.on("session_before_compact", (event) => {
+        const spanId = nextTraceSpan("compaction");
+        pendingCompactionSpans.push(spanId);
+        trace.record({
+          type: "compaction",
+          spanId,
+          status: "started",
+          attributes: {
+            reason: event.reason,
+            willRetry: event.willRetry,
+            branchEntries: event.branchEntries.length,
+          },
+        });
+      });
+
+      pi.on("session_compact", (event) => {
+        const spanId = pendingCompactionSpans.shift() ?? nextTraceSpan("compaction-result");
+        trace.record({
+          type: "compaction",
+          spanId,
+          status: "completed",
+          attributes: {
+            reason: event.reason,
+            willRetry: event.willRetry,
+            tokensBefore: event.compactionEntry.tokensBefore,
+          },
+        });
+      });
+
       pi.on("user_bash", (_event, ctx) => {
         const operations: BashOperations = {
           exec: async (command, cwd, execution) => {
@@ -420,12 +735,54 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
 
       pi.on("message_end", (event) => {
         if (event.message.role !== "assistant") return;
+        fixtureRecorder?.record(event.message);
+        const modelSpanId = pendingModelSpans.shift() ?? nextTraceSpan("model-response");
+        const stopReason =
+          "stopReason" in event.message && typeof event.message.stopReason === "string"
+            ? event.message.stopReason
+            : undefined;
+        const usage =
+          "usage" in event.message && event.message.usage
+            ? usageFromPiUsage(event.message.usage)
+            : undefined;
+        trace.record({
+          type: "model_response",
+          spanId: modelSpanId,
+          status: stopReason === "error" || stopReason === "aborted" ? "failed" : "completed",
+          provider: options.providerId,
+          model: options.modelId,
+          ...(usage ? { usage } : {}),
+          content: summarizeContent(event.message.content),
+          ...(stopReason ? { attributes: { stopReason } } : {}),
+        });
         lastAgentFailed =
           "stopReason" in event.message &&
           (event.message.stopReason === "error" || event.message.stopReason === "aborted");
+        if (lastAgentFailed && !traceErrorRecorded) {
+          traceErrorRecorded = true;
+          trace.recordError(
+            nextTraceSpan("error"),
+            event.message.stopReason === "aborted" ? "aborted" : "provider",
+            "model response failed",
+            {
+              stopReason:
+                "stopReason" in event.message && typeof event.message.stopReason === "string"
+                  ? event.message.stopReason
+                  : "unknown",
+            },
+          );
+        }
       });
 
       pi.on("agent_end", async (_event, ctx) => {
+        const traceId = trace.getTraceId();
+        if (traceId) {
+          trace.record({
+            type: "agent_end",
+            spanId: `agent:${traceId}`,
+            status: lastAgentFailed ? "failed" : "completed",
+          });
+        }
         if (
           permission !== "plan" ||
           ctx.mode !== "tui" ||
@@ -568,10 +925,59 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
             return;
           }
           pi.setThinkingLevel(value as ThinkingLevel);
+          effortManuallyChanged = true;
           ctx.ui.notify(`Thinking effort: ${pi.getThinkingLevel()}`, "info");
         },
       });
 
+      pi.registerCommand("route", {
+        description: "Show or set auto|bootstrap|standard|deep|repair route profile",
+        handler: async (args, ctx) => {
+          const value = args.trim();
+          if (!value || value === "status") {
+            ctx.ui.notify(
+              [
+                `route: ${formatRouteStatus(routeState)}`,
+                `phase: ${formatRoutePhaseStatus(routePhaseState)}`,
+                `thinking: ${pi.getThinkingLevel()}${effortManuallyChanged ? " (manual)" : ""}`,
+                routeCommandUsage(),
+              ].join("\n"),
+              "info",
+            );
+            return;
+          }
+
+          const selection = parseRouteSelection(value);
+          if (!selection) {
+            ctx.ui.notify(routeCommandUsage(), "warning");
+            return;
+          }
+
+          if (selection === "auto") {
+            const autoRoute = classifyCurrentRoute(undefined, ctx);
+            routeState = {
+              ...autoRoute,
+              reason: `manual auto reset · ${autoRoute.reason}`,
+            };
+          } else {
+            routeState = createRouteState(selection, "manual", "manual /route override", 1);
+          }
+          pi.appendEntry(ROUTE_STATE_ENTRY, routeState);
+          resetRoutePhase(routeState);
+          const boostedThinking = applyRouteThinkingBoost(routeState);
+          updateStatus(ctx);
+          const thinkingNote = boostedThinking
+            ? `thinking: ${pi.getThinkingLevel()} (route boosted)`
+            : effortManuallyChanged
+              ? `thinking: ${pi.getThinkingLevel()} (manual effort preserved)`
+              : `thinking: ${pi.getThinkingLevel()}`;
+          ctx.ui.notify(
+            `Route profile: ${routeProfileLabel(routeState.profile)}\n${formatRouteStatus(routeState)}\nphase: ${formatRoutePhaseStatus(routePhaseState)}\n${thinkingNote}`,
+            "info",
+          );
+        },
+      });
+
       pi.registerCommand("base-url", {
         description: "Show or save the DeepSeek-compatible API base URL",
         handler: async (args, ctx) => {
@@ -712,6 +1118,8 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
               branch: git?.stdout.trim() || undefined,
               sessionName: ctx.sessionManager.getSessionName(),
               sessionFile: ctx.sessionManager.getSessionFile() ?? undefined,
+              route: routeState,
+              routePhase: routePhaseState,
               context: usage
                 ? {
                     tokens: usage.tokens ?? 0,
@@ -737,6 +1145,8 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
               `transport: ${ctx.model?.api ?? options.transport}`,
               `image input: ${ctx.model?.input.includes("image") ? "supported" : "not supported"}`,
               `thinking: ${ctx.thinkingLevel ?? pi.getThinkingLevel()}`,
+              `route: ${formatRouteStatus(routeState)}`,
+              `route phase: ${formatRoutePhaseStatus(routePhaseState)}`,
               `permission: ${permission}`,
               `sandbox: ${sandboxDescription({
                 mode: currentAccess.sandbox,
@@ -762,8 +1172,16 @@ export function createDSCodeExtension(options: DSCodeRuntimeOptions): InlineExte
   };
 }
 
-function registerDeepSeekProvider(pi: ExtensionAPI, options: DSCodeRuntimeOptions): void {
-  const api = options.transport === "responses" ? "openai-responses" : "openai-completions";
+function registerDeepSeekProvider(
+  pi: ExtensionAPI,
+  options: DSCodeRuntimeOptions,
+  fixtureReplay?: AgentFixtureReplay,
+): void {
+  const api = fixtureReplay
+    ? "dscode-fixture"
+    : options.transport === "responses"
+      ? "openai-responses"
+      : "openai-completions";
   const models = [
     {
       id: "deepseek-v4-flash",
@@ -792,9 +1210,11 @@ function registerDeepSeekProvider(pi: ExtensionAPI, options: DSCodeRuntimeOption
   pi.registerProvider("deepseek", {
     name: "DeepSeek",
     baseUrl: options.baseUrl,
-    apiKey: "$DEEPSEEK_API_KEY",
+    apiKey: fixtureReplay ? "dscode-fixture" : "$DEEPSEEK_API_KEY",
     api,
-    authHeader: true,
+    ...(fixtureReplay
+      ? { streamSimple: (model, context, streamOptions) => fixtureReplay.stream(model, context, streamOptions) }
+      : { authHeader: true }),
     models: models.map((model) => ({
       id: model.id,
       name: model.name,
diff --git a/packages/core/src/evaluation.ts b/packages/core/src/evaluation.ts
new file mode 100644
index 0000000..4bd206c
--- /dev/null
+++ b/packages/core/src/evaluation.ts
@@ -0,0 +1,124 @@
+import type { AgentTraceEvent } from "./observability.js";
+import { replayTraceLines, summarizeTrace, type TraceReplayReport } from "./replay.js";
+
+export interface EvaluationOptions {
+  maxToolCalls?: number;
+  maxDurationMs?: number;
+  maxTotalTokens?: number;
+  maxCost?: number;
+  requireSuccessfulRun?: boolean;
+  failOnErrors?: boolean;
+}
+
+export interface EvaluationResult {
+  passed: boolean;
+  turns: number;
+  modelRequests: number;
+  toolCalls: number;
+  toolFailures: number;
+  durationMs: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cost: number;
+  approvals: number;
+  errors: number;
+  violations: string[];
+  replay: TraceReplayReport;
+}
+
+export function evaluateTrace(
+  events: AgentTraceEvent[],
+  options: EvaluationOptions = {},
+): EvaluationResult {
+  return evaluateReplay(summarizeTrace(events), options);
+}
+
+export function evaluateTraceLines(
+  lines: string[],
+  options: EvaluationOptions = {},
+): EvaluationResult {
+  return evaluateReplay(replayTraceLines(lines), options);
+}
+
+export function evaluateReplay(
+  replay: TraceReplayReport,
+  options: EvaluationOptions = {},
+): EvaluationResult {
+  const violations = [...replay.violations];
+  const requireSuccessfulRun = options.requireSuccessfulRun ?? true;
+  const failOnErrors = options.failOnErrors ?? true;
+  if (requireSuccessfulRun && replay.finalStatus !== "completed") {
+    violations.push(`run did not complete successfully: ${replay.finalStatus ?? "missing"}`);
+  }
+  if (failOnErrors && replay.counts.errors > 0) {
+    violations.push(`runtime errors: ${replay.counts.errors}`);
+  }
+  if (options.maxToolCalls !== undefined && replay.counts.toolCalls > options.maxToolCalls) {
+    violations.push(`tool call budget exceeded: ${replay.counts.toolCalls} > ${options.maxToolCalls}`);
+  }
+  if (options.maxDurationMs !== undefined && replay.durationMs > options.maxDurationMs) {
+    violations.push(`duration budget exceeded: ${replay.durationMs}ms > ${options.maxDurationMs}ms`);
+  }
+  if (options.maxTotalTokens !== undefined && replay.usage.totalTokens > options.maxTotalTokens) {
+    violations.push(
+      `token budget exceeded: ${replay.usage.totalTokens} > ${options.maxTotalTokens}`,
+    );
+  }
+  if (options.maxCost !== undefined && replay.usage.cost > options.maxCost) {
+    violations.push(`cost budget exceeded: $${replay.usage.cost} > $${options.maxCost}`);
+  }
+  return {
+    passed: violations.length === 0,
+    turns: replay.counts.turns,
+    modelRequests: replay.counts.modelRequests,
+    toolCalls: replay.counts.toolCalls,
+    toolFailures: replay.counts.toolFailures,
+    durationMs: replay.durationMs,
+    inputTokens: replay.usage.inputTokens,
+    outputTokens: replay.usage.outputTokens,
+    cacheReadTokens: replay.usage.cacheReadTokens,
+    cost: replay.usage.cost,
+    approvals: replay.counts.approvals,
+    errors: replay.counts.errors,
+    violations,
+    replay,
+  };
+}
+
+export function formatEvaluationResult(result: EvaluationResult, json = false): string {
+  if (json) {
+    return JSON.stringify(
+      {
+        passed: result.passed,
+        turns: result.turns,
+        modelRequests: result.modelRequests,
+        modelResponses: result.replay.counts.modelResponses,
+        toolCalls: result.toolCalls,
+        toolFailures: result.toolFailures,
+        durationMs: result.durationMs,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        cacheReadTokens: result.cacheReadTokens,
+        cost: result.cost,
+        approvals: result.approvals,
+        errors: result.errors,
+        violations: result.violations,
+      },
+      null,
+      2,
+    );
+  }
+  return [
+    `Evaluation ${result.passed ? "PASSED" : "FAILED"}`,
+    `turns       ${result.turns}`,
+    `models      ${result.modelRequests} request(s), ${result.replay.counts.modelResponses} response(s)`,
+    `tools       ${result.toolCalls} (${result.toolFailures} failure(s))`,
+    `duration    ${result.durationMs}ms`,
+    `tokens      ${result.inputTokens} input · ${result.outputTokens} output · ${result.cacheReadTokens} cache read`,
+    `cost        $${result.cost.toFixed(4)}`,
+    `approvals   ${result.approvals}`,
+    `errors      ${result.errors}`,
+    ...(result.violations.length ? ["violations  ", ...result.violations.map((value) => `  ${value}`)] : []),
+  ].join("\n");
+}
diff --git a/packages/core/src/fixture.ts b/packages/core/src/fixture.ts
new file mode 100644
index 0000000..a44a01e
--- /dev/null
+++ b/packages/core/src/fixture.ts
@@ -0,0 +1,409 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import {
+  createAssistantMessageEventStream,
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  type Context,
+  type Model,
+  type SimpleStreamOptions,
+  type StopReason,
+  type ThinkingContent,
+  type TextContent,
+  type ToolCall,
+  type Usage,
+} from "@earendil-works/pi-ai";
+import type { AgentTraceStatus } from "./observability.js";
+
+export const AGENT_FIXTURE_SCHEMA_VERSION = 1 as const;
+export const AGENT_FIXTURE_KIND = "dscode-agent-fixture" as const;
+
+export type FixtureContentBlock = TextContent | ThinkingContent | ToolCall;
+export type FixtureStopReason = Exclude<StopReason, "pending">;
+
+export interface FixtureUsage {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  totalTokens: number;
+  cost: Usage["cost"];
+}
+
+export interface AgentFixtureResponse {
+  content: FixtureContentBlock[];
+  stopReason: FixtureStopReason;
+  usage?: FixtureUsage;
+  responseId?: string;
+  errorMessage?: string;
+  delayMs?: number;
+}
+
+export interface AgentFixtureEvaluation {
+  maxToolCalls?: number;
+  maxDurationMs?: number;
+  maxTotalTokens?: number;
+  maxCost?: number;
+  requireSuccessfulRun?: boolean;
+  failOnErrors?: boolean;
+}
+
+export interface AgentFixtureAssertions {
+  finalStatus?: AgentTraceStatus;
+  toolNames?: string[];
+  modelResponses?: number;
+}
+
+export interface AgentFixture {
+  schemaVersion: typeof AGENT_FIXTURE_SCHEMA_VERSION;
+  kind: typeof AGENT_FIXTURE_KIND;
+  provider: string;
+  model: string;
+  responses: AgentFixtureResponse[];
+  evaluation?: AgentFixtureEvaluation;
+  assertions?: AgentFixtureAssertions;
+}
+
+export class AgentFixtureRecorder {
+  private readonly responses: AgentFixtureResponse[] = [];
+  private finished = false;
+
+  constructor(
+    private readonly filePath: string,
+    private readonly provider: string,
+    private readonly model: string,
+  ) {}
+
+  record(message: AssistantMessage): void {
+    if (this.finished || message.role !== "assistant") return;
+    this.responses.push({
+      content: message.content.map(cloneFixtureContent),
+      stopReason: message.stopReason === "pending" ? "error" : message.stopReason,
+      usage: cloneUsage(message.usage),
+      ...(message.responseId ? { responseId: message.responseId } : {}),
+      ...(message.errorMessage ? { errorMessage: message.errorMessage } : {}),
+    });
+  }
+
+  async finish(): Promise<void> {
+    if (this.finished) return;
+    this.finished = true;
+    await writeAgentFixture(this.filePath, {
+      schemaVersion: AGENT_FIXTURE_SCHEMA_VERSION,
+      kind: AGENT_FIXTURE_KIND,
+      provider: this.provider,
+      model: this.model,
+      responses: this.responses,
+    });
+  }
+}
+
+export class AgentFixtureReplay {
+  private nextResponse = 0;
+  private calls = 0;
+
+  constructor(private readonly fixture: AgentFixture) {}
+
+  stream(
+    model: Model<Api>,
+    _context: Context,
+    options?: SimpleStreamOptions,
+  ): AssistantMessageEventStream {
+    const stream = createAssistantMessageEventStream();
+    const response = this.fixture.responses[this.nextResponse++];
+    this.calls += 1;
+    void this.resolve(stream, model, response, options?.signal);
+    return stream;
+  }
+
+  consumedResponses(): number {
+    return this.nextResponse;
+  }
+
+  callCount(): number {
+    return this.calls;
+  }
+
+  pendingResponses(): number {
+    return Math.max(0, this.fixture.responses.length - this.nextResponse);
+  }
+
+  private async resolve(
+    stream: AssistantMessageEventStream,
+    model: Model<Api>,
+    response: AgentFixtureResponse | undefined,
+    signal: AbortSignal | undefined,
+  ): Promise<void> {
+    try {
+      if (response?.delayMs) await delay(response.delayMs, signal);
+      const message = response
+        ? messageFromFixture(response, model)
+        : errorMessage(model, "Fixture has no response for this model request");
+      if (signal?.aborted) {
+        endAborted(stream, model);
+        return;
+      }
+      const partial: AssistantMessage = { ...message, content: [], stopReason: "pending" };
+      stream.push({ type: "start", partial });
+      if (message.stopReason === "pending") {
+        const error = { ...message, stopReason: "error" as const };
+        stream.push({ type: "error", reason: "error", error });
+        stream.end(error);
+        return;
+      }
+      if (message.stopReason === "error" || message.stopReason === "aborted") {
+        stream.push({ type: "error", reason: message.stopReason, error: message });
+        stream.end(message);
+        return;
+      }
+      stream.push({ type: "done", reason: message.stopReason, message });
+      stream.end(message);
+    } catch (error) {
+      if (signal?.aborted || isFixtureAbortError(error)) {
+        endAborted(stream, model);
+        return;
+      }
+      const message = errorMessage(model, error instanceof Error ? error.message : String(error));
+      stream.push({ type: "error", reason: "error", error: message });
+      stream.end(message);
+    }
+  }
+}
+
+function endAborted(
+  stream: AssistantMessageEventStream,
+  model: Model<Api>,
+): void {
+  const aborted = {
+    ...errorMessage(model, "Request was aborted"),
+    stopReason: "aborted" as const,
+  };
+  stream.push({ type: "error", reason: "aborted", error: aborted });
+  stream.end(aborted);
+}
+
+export function readAgentFixtureFileSync(filePath: string): AgentFixture {
+  return parseAgentFixture(fs.readFileSync(filePath, "utf8"), filePath);
+}
+
+export async function readAgentFixtureFile(filePath: string): Promise<AgentFixture> {
+  return parseAgentFixture(await fsp.readFile(filePath, "utf8"), filePath);
+}
+
+export async function writeAgentFixture(filePath: string, fixture: AgentFixture): Promise<void> {
+  await fsp.mkdir(path.dirname(path.resolve(filePath)), { recursive: true, mode: 0o700 });
+  await fsp.writeFile(filePath, `${JSON.stringify(fixture, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  await fsp.chmod(filePath, 0o600).catch(() => undefined);
+}
+
+function parseAgentFixture(raw: string, source: string): AgentFixture {
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid agent fixture JSON: ${source}`);
+  }
+  if (!isRecord(value)) throw new Error(`Invalid agent fixture envelope: ${source}`);
+  if (
+    value.schemaVersion !== AGENT_FIXTURE_SCHEMA_VERSION ||
+    value.kind !== AGENT_FIXTURE_KIND ||
+    typeof value.provider !== "string" ||
+    typeof value.model !== "string" ||
+    !Array.isArray(value.responses) ||
+    value.responses.length === 0
+  ) {
+    throw new Error(`Invalid agent fixture schema: ${source}`);
+  }
+  const responses = value.responses.map((response, index) => parseResponse(response, `${source} response ${index + 1}`));
+  return {
+    schemaVersion: AGENT_FIXTURE_SCHEMA_VERSION,
+    kind: AGENT_FIXTURE_KIND,
+    provider: value.provider,
+    model: value.model,
+    responses,
+    ...(isRecord(value.evaluation) ? { evaluation: parseEvaluation(value.evaluation) } : {}),
+    ...(isRecord(value.assertions) ? { assertions: parseAssertions(value.assertions) } : {}),
+  };
+}
+
+function parseResponse(value: unknown, source: string): AgentFixtureResponse {
+  if (!isRecord(value) || !Array.isArray(value.content) || typeof value.stopReason !== "string") {
+    throw new Error(`Invalid agent fixture response: ${source}`);
+  }
+  if (!["stop", "length", "toolUse", "error", "aborted"].includes(value.stopReason)) {
+    throw new Error(`Invalid fixture stopReason: ${source}`);
+  }
+  const content = value.content.map((block, index) => parseContent(block, `${source} content ${index + 1}`));
+  const response: AgentFixtureResponse = {
+    content,
+    stopReason: value.stopReason as FixtureStopReason,
+    ...(typeof value.responseId === "string" ? { responseId: value.responseId } : {}),
+    ...(typeof value.errorMessage === "string" ? { errorMessage: value.errorMessage } : {}),
+    ...(typeof value.delayMs === "number" && value.delayMs >= 0 ? { delayMs: value.delayMs } : {}),
+  };
+  if (isRecord(value.usage)) response.usage = parseUsage(value.usage, source);
+  return response;
+}
+
+function parseContent(value: unknown, source: string): FixtureContentBlock {
+  if (!isRecord(value) || typeof value.type !== "string") throw new Error(`Invalid fixture content: ${source}`);
+  if (value.type === "text" && typeof value.text === "string") return { type: "text", text: value.text };
+  if (value.type === "thinking" && typeof value.thinking === "string") {
+    return { type: "thinking", thinking: value.thinking };
+  }
+  if (
+    value.type === "toolCall" &&
+    typeof value.id === "string" &&
+    typeof value.name === "string" &&
+    isRecord(value.arguments)
+  ) {
+    return { type: "toolCall", id: value.id, name: value.name, arguments: value.arguments };
+  }
+  throw new Error(`Invalid fixture content: ${source}`);
+}
+
+function parseUsage(value: Record<string, unknown>, source: string): FixtureUsage {
+  const cost = isRecord(value.cost) ? value.cost : undefined;
+  const numbers = ["input", "output", "cacheRead", "cacheWrite", "totalTokens"];
+  if (!numbers.every((key) => typeof value[key] === "number") || !cost) {
+    throw new Error(`Invalid fixture usage: ${source}`);
+  }
+  const costKeys = ["input", "output", "cacheRead", "cacheWrite", "total"];
+  if (!costKeys.every((key) => typeof cost[key] === "number")) {
+    throw new Error(`Invalid fixture cost: ${source}`);
+  }
+  return {
+    input: value.input as number,
+    output: value.output as number,
+    cacheRead: value.cacheRead as number,
+    cacheWrite: value.cacheWrite as number,
+    totalTokens: value.totalTokens as number,
+    cost: {
+      input: cost.input as number,
+      output: cost.output as number,
+      cacheRead: cost.cacheRead as number,
+      cacheWrite: cost.cacheWrite as number,
+      total: cost.total as number,
+    },
+  };
+}
+
+function parseEvaluation(value: Record<string, unknown>): AgentFixtureEvaluation {
+  const result: AgentFixtureEvaluation = {};
+  for (const key of ["maxToolCalls", "maxDurationMs", "maxTotalTokens", "maxCost"] as const) {
+    if (typeof value[key] === "number" && value[key] >= 0) result[key] = value[key];
+  }
+  if (typeof value.requireSuccessfulRun === "boolean") result.requireSuccessfulRun = value.requireSuccessfulRun;
+  if (typeof value.failOnErrors === "boolean") result.failOnErrors = value.failOnErrors;
+  return result;
+}
+
+function parseAssertions(value: Record<string, unknown>): AgentFixtureAssertions {
+  const result: AgentFixtureAssertions = {};
+  if (value.finalStatus === "completed" || value.finalStatus === "failed" || value.finalStatus === "cancelled") {
+    result.finalStatus = value.finalStatus;
+  }
+  if (Array.isArray(value.toolNames) && value.toolNames.every((name) => typeof name === "string")) {
+    result.toolNames = value.toolNames as string[];
+  }
+  if (typeof value.modelResponses === "number" && value.modelResponses >= 0) result.modelResponses = value.modelResponses;
+  return result;
+}
+
+function messageFromFixture(response: AgentFixtureResponse, model: Model<Api>): AssistantMessage {
+  return {
+    role: "assistant",
+    content: response.content.map(cloneFixtureContent),
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: response.usage ?? emptyUsage(),
+    stopReason: response.stopReason,
+    ...(response.responseId ? { responseId: response.responseId } : {}),
+    ...(response.errorMessage ? { errorMessage: response.errorMessage } : {}),
+    timestamp: Date.now(),
+  };
+}
+
+function errorMessage(model: Model<Api>, message: string): AssistantMessage {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: emptyUsage(),
+    stopReason: "error",
+    errorMessage: message,
+    timestamp: Date.now(),
+  };
+}
+
+function emptyUsage(): Usage {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  };
+}
+
+function cloneUsage(usage: Usage): FixtureUsage {
+  return {
+    input: usage.input,
+    output: usage.output,
+    cacheRead: usage.cacheRead,
+    cacheWrite: usage.cacheWrite,
+    totalTokens: usage.totalTokens,
+    cost: { ...usage.cost },
+  };
+}
+
+function cloneFixtureContent(block: FixtureContentBlock): FixtureContentBlock {
+  if (block.type === "text") return { type: "text", text: block.text };
+  if (block.type === "thinking") return { type: "thinking", thinking: block.thinking };
+  return { type: "toolCall", id: block.id, name: block.name, arguments: structuredClone(block.arguments) };
+}
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function delay(milliseconds: number, signal: AbortSignal | undefined): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new FixtureAbortError());
+      return;
+    }
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const onAbort = () => {
+      if (timer !== undefined) clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(new FixtureAbortError());
+    };
+    timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, milliseconds);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+  });
+}
+
+class FixtureAbortError extends Error {
+  constructor() {
+    super("Request was aborted");
+    this.name = "AbortError";
+  }
+}
+
+function isFixtureAbortError(error: unknown): boolean {
+  return error instanceof FixtureAbortError;
+}
diff --git a/packages/core/src/home.ts b/packages/core/src/home.ts
index 13a7666..d9f704d 100644
--- a/packages/core/src/home.ts
+++ b/packages/core/src/home.ts
@@ -35,6 +35,12 @@ export function getDSCodeArchivedSessionsDir(): string {
   );
 }
 
+export function getDSCodeTracesDir(): string {
+  return resolveHomePath(
+    process.env.DSCODE_TRACE_DIR ?? path.join(getDSCodeHome(), "traces"),
+  );
+}
+
 /** Configure the underlying runtime to use DSCode-owned paths only. */
 export async function initializeDSCodeHome(): Promise<string> {
   const home = getDSCodeHome();
@@ -51,6 +57,8 @@ export async function initializeDSCodeHome(): Promise<string> {
   await fs.chmod(sessions, 0o700).catch(() => undefined);
   await fs.mkdir(getDSCodeArchivedSessionsDir(), { recursive: true, mode: 0o700 });
   await fs.chmod(getDSCodeArchivedSessionsDir(), 0o700).catch(() => undefined);
+  await fs.mkdir(getDSCodeTracesDir(), { recursive: true, mode: 0o700 });
+  await fs.chmod(getDSCodeTracesDir(), 0o700).catch(() => undefined);
   await partitionExistingSessions(sessions);
   return home;
 }
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 0902a1c..daaa178 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -41,6 +41,7 @@ export {
   getDSCodeArchivedSessionsDir,
   getDSCodeHome,
   getDSCodeSessionsDir,
+  getDSCodeTracesDir,
   initializeDSCodeHome,
   migrateLegacyDSCodeHome,
   partitionExistingSessions,
@@ -88,6 +89,38 @@ export {
   type ParsedRuntimeArgs,
   type SandboxMode,
 } from "./runtime-options.js";
+export {
+  classifyRoute,
+  createRoutePhaseState,
+  createRouteState,
+  formatRoutePhaseStatus,
+  formatRouteStatus,
+  isOpeningRouteTurn,
+  latestUserMessageText,
+  parseRouteSelection,
+  restoreRoutePhaseState,
+  restoreRouteState,
+  routeCommandUsage,
+  routePhaseTraceAttributes,
+  routeProfileLabel,
+  routeProfileShortLabel,
+  routeStateTraceAttributes,
+  routeSystemPrompt,
+  routeThinkingBoost,
+  routeThinkingTarget,
+  ROUTE_PROFILE_IDS,
+  ROUTE_THINKING_TARGETS,
+  ROUTE_PHASE_ENTRY,
+  ROUTE_STATE_ENTRY,
+  type RoutePhase,
+  type RoutePhaseState,
+  type RouteProfileId,
+  type RouteSelection,
+  type RouteSelectionInput,
+  type RouteSource,
+  type RouteState,
+  type RouteThinkingTarget,
+} from "./route-profile.js";
 export {
   PERSONALIZATION_TONE_IDS,
   buildPersonalizationPrompt,
@@ -97,3 +130,55 @@ export {
   type PersonalizationTone,
 } from "./personalization.js";
 export { DSCODE_VERSION } from "./version.js";
+export {
+  AGENT_TRACE_SCHEMA_VERSION,
+  AgentRuntimeTrace,
+  classifyHttpStatus,
+  summarizeContent,
+  summarizeValue,
+  usageFromPiUsage,
+  type AgentRuntimeTraceOptions,
+  type AgentTraceError,
+  type AgentTraceEvent,
+  type AgentTraceEventInput,
+  type AgentTraceEventType,
+  type AgentTraceStatus,
+  type AgentTraceUsage,
+  type TraceContentSummary,
+  type TraceValueSummary,
+} from "./observability.js";
+export {
+  compareTraceReports,
+  formatReplayReport,
+  readTraceFile,
+  replayTraceLines,
+  summarizeTrace,
+  type TraceComparison,
+  type TraceCounts,
+  type TraceReplayReport,
+  type TraceUsageSummary,
+} from "./replay.js";
+export {
+  evaluateReplay,
+  evaluateTrace,
+  evaluateTraceLines,
+  formatEvaluationResult,
+  type EvaluationOptions,
+  type EvaluationResult,
+} from "./evaluation.js";
+export {
+  AGENT_FIXTURE_KIND,
+  AGENT_FIXTURE_SCHEMA_VERSION,
+  AgentFixtureRecorder,
+  AgentFixtureReplay,
+  readAgentFixtureFile,
+  readAgentFixtureFileSync,
+  writeAgentFixture,
+  type AgentFixture,
+  type AgentFixtureAssertions,
+  type AgentFixtureEvaluation,
+  type AgentFixtureResponse,
+  type FixtureContentBlock,
+  type FixtureStopReason,
+  type FixtureUsage,
+} from "./fixture.js";
diff --git a/packages/core/src/mcp.ts b/packages/core/src/mcp.ts
index f2b19a0..dd2ac0e 100644
--- a/packages/core/src/mcp.ts
+++ b/packages/core/src/mcp.ts
@@ -46,7 +46,7 @@ export class MCPManager {
       this.errors.push("Project is not trusted; project MCP servers were not started.");
     }
     const configs = await loadMcpConfigs(ctx.cwd, trusted);
-    for (const [serverName, config] of Object.entries(configs)) {
+    for (const [serverName, config] of Object.entries(configs).sort(([left], [right]) => compareText(left, right))) {
       if (config.disabled) continue;
       try {
         await this.connectServer(pi, ctx, serverName, config);
@@ -65,7 +65,7 @@ export class MCPManager {
   }
 
   toolNames(): string[] {
-    return this.servers.flatMap((server) => server.tools);
+    return this.servers.flatMap((server) => server.tools).sort(compareText);
   }
 
   async close(): Promise<void> {
@@ -105,10 +105,22 @@ export class MCPManager {
       }
 
       const listed = await client.listTools();
-      const registered: string[] = [];
-      for (const tool of listed.tools) {
-        const localName = `mcp__${sanitizeName(serverName)}__${sanitizeName(tool.name)}`;
-        registered.push(localName);
+      const existingNames = new Set(this.servers.flatMap((server) => server.tools));
+      const prepared = [...listed.tools]
+        .sort((left, right) => compareText(left.name, right.name))
+        .map((tool) => ({
+          tool,
+          localName: `mcp__${sanitizeName(serverName)}__${sanitizeName(tool.name)}`,
+        }));
+      const registered = prepared.map(({ localName }) => localName);
+      const seenNames = new Set(existingNames);
+      for (const { localName } of prepared) {
+        if (seenNames.has(localName)) {
+          throw new Error(`MCP tool name collision after sanitization: ${localName}`);
+        }
+        seenNames.add(localName);
+      }
+      for (const { tool, localName } of prepared) {
         pi.registerTool({
           name: localName,
           label: `${serverName}: ${tool.title ?? tool.name}`,
@@ -190,6 +202,10 @@ function sanitizeName(value: string): string {
   return value.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 
+function compareText(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
 interface FormattedMcpResult {
   content: Array<TextContent | ImageContent>;
   text: string;
diff --git a/packages/core/src/observability.ts b/packages/core/src/observability.ts
new file mode 100644
index 0000000..fdbed93
--- /dev/null
+++ b/packages/core/src/observability.ts
@@ -0,0 +1,350 @@
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getDSCodeTracesDir } from "./home.js";
+
+export const AGENT_TRACE_SCHEMA_VERSION = 1 as const;
+
+export type AgentTraceEventType =
+  | "run_start"
+  | "agent_start"
+  | "turn_start"
+  | "turn_end"
+  | "model_request"
+  | "provider_response"
+  | "model_response"
+  | "tool_call"
+  | "tool_result"
+  | "approval"
+  | "compaction"
+  | "agent_end"
+  | "run_end"
+  | "error"
+  | "session_shutdown";
+
+export type AgentTraceStatus = "started" | "completed" | "failed" | "cancelled";
+
+export interface AgentTraceUsage {
+  input?: number;
+  output?: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+  total?: number;
+  cost?: number;
+}
+
+export interface TraceValueSummary {
+  kind: "text" | "json" | "binary" | "unknown";
+  bytes: number;
+  sha256: string;
+}
+
+export interface TraceContentSummary {
+  items: number;
+  textItems: number;
+  imageItems: number;
+  bytes: number;
+  sha256: string;
+}
+
+export interface AgentTraceError {
+  code: string;
+  message: string;
+}
+
+export interface AgentTraceEvent {
+  schemaVersion: typeof AGENT_TRACE_SCHEMA_VERSION;
+  traceId: string;
+  sessionId?: string;
+  runId?: string;
+  turnId?: string;
+  spanId: string;
+  parentSpanId?: string;
+  timestamp: string;
+  type: AgentTraceEventType;
+  status?: AgentTraceStatus;
+  durationMs?: number;
+  provider?: string;
+  model?: string;
+  toolName?: string;
+  toolCallId?: string;
+  usage?: AgentTraceUsage;
+  error?: AgentTraceError;
+  input?: TraceValueSummary;
+  output?: TraceValueSummary;
+  content?: TraceContentSummary;
+  attributes?: Record<string, string | number | boolean>;
+}
+
+export type AgentTraceEventInput = Omit<
+  AgentTraceEvent,
+  "schemaVersion" | "traceId" | "sessionId" | "runId" | "timestamp" | "durationMs"
+> & {
+  durationMs?: number;
+};
+
+export interface AgentRuntimeTraceOptions {
+  traceDir?: string;
+  enabled?: boolean;
+  now?: () => Date;
+  createId?: () => string;
+}
+
+interface ActiveRun {
+  traceId: string;
+  runId: string;
+  sessionId?: string;
+  spanId: string;
+  filePath: string;
+  startedAt: number;
+  closed: boolean;
+}
+
+/**
+ * Small, local-first event sink for agent runs. Writes are queued so telemetry
+ * cannot block the agent loop; callers can await flush at lifecycle boundaries.
+ */
+export class AgentRuntimeTrace {
+  private readonly traceDir: string;
+  private readonly enabled: boolean;
+  private readonly now: () => Date;
+  private readonly createId: () => string;
+  private sessionId: string | undefined;
+  private activeRun: ActiveRun | undefined;
+  private readonly spanStarts = new Map<string, number>();
+  private writeQueue: Promise<void> = Promise.resolve();
+
+  constructor(options: AgentRuntimeTraceOptions = {}) {
+    this.traceDir = path.resolve(options.traceDir ?? getDSCodeTracesDir());
+    this.enabled =
+      options.enabled ??
+      !["0", "false", "off"].includes((process.env.DSCODE_TRACE ?? "1").toLowerCase());
+    this.now = options.now ?? (() => new Date());
+    this.createId = options.createId ?? randomUUID;
+  }
+
+  setSession(sessionId: string | undefined): void {
+    this.sessionId = sessionId;
+  }
+
+  startRun(metadata: {
+    sessionId?: string;
+    provider?: string;
+    model?: string;
+  } = {}): string {
+    if (this.activeRun && !this.activeRun.closed) this.endRun("cancelled");
+    this.spanStarts.clear();
+    const traceId = this.createId();
+    const runId = this.createId();
+    const sessionId = metadata.sessionId ?? this.sessionId;
+    const startedAt = this.now().getTime();
+    this.activeRun = {
+      traceId,
+      runId,
+      ...(sessionId ? { sessionId } : {}),
+      spanId: `run:${runId}`,
+      filePath: path.join(this.traceDir, `${traceFileTimestamp(startedAt)}-${traceId}.jsonl`),
+      startedAt,
+      closed: false,
+    };
+    this.record({
+      type: "run_start",
+      spanId: `run:${runId}`,
+      status: "started",
+      ...(metadata.provider ? { provider: metadata.provider } : {}),
+      ...(metadata.model ? { model: metadata.model } : {}),
+    });
+    return traceId;
+  }
+
+  record(event: AgentTraceEventInput): void {
+    const run = this.activeRun;
+    if (!run || run.closed) return;
+    const timestamp = this.now();
+    const timestampMs = timestamp.getTime();
+    const durationMs =
+      event.durationMs ??
+      (event.status !== "started" && this.spanStarts.has(event.spanId)
+        ? Math.max(0, timestampMs - this.spanStarts.get(event.spanId)!)
+        : undefined);
+    if (event.status === "started") this.spanStarts.set(event.spanId, timestampMs);
+    if (event.status !== "started") this.spanStarts.delete(event.spanId);
+
+    const traceEvent: AgentTraceEvent = {
+      schemaVersion: AGENT_TRACE_SCHEMA_VERSION,
+      traceId: run.traceId,
+      ...(run.sessionId ? { sessionId: run.sessionId } : {}),
+      runId: run.runId,
+      timestamp: timestamp.toISOString(),
+      ...event,
+      ...(durationMs === undefined ? {} : { durationMs }),
+    };
+    this.enqueue(traceEvent, run.filePath);
+  }
+
+  recordError(
+    spanId: string,
+    code: string,
+    message = "runtime error",
+    attributes?: Record<string, string | number | boolean>,
+  ): void {
+    this.record({
+      type: "error",
+      spanId,
+      status: "failed",
+      error: { code, message: sanitizeErrorMessage(message) },
+      ...(attributes ? { attributes } : {}),
+    });
+  }
+
+  endRun(status: Exclude<AgentTraceStatus, "started"> = "completed"): void {
+    const run = this.activeRun;
+    if (!run || run.closed) return;
+    this.record({ type: "run_end", spanId: run.spanId, status });
+    run.closed = true;
+    this.spanStarts.delete(run.spanId);
+  }
+
+  shutdown(reason: "completed" | "cancelled" = "cancelled"): void {
+    if (this.activeRun && !this.activeRun.closed) {
+      this.record({
+        type: "session_shutdown",
+        spanId: `shutdown:${this.activeRun.runId}`,
+        status: reason === "completed" ? "completed" : "cancelled",
+      });
+      this.endRun(reason);
+    }
+  }
+
+  getTracePath(): string | undefined {
+    return this.activeRun?.filePath;
+  }
+
+  getTraceId(): string | undefined {
+    return this.activeRun?.traceId;
+  }
+
+  async flush(): Promise<void> {
+    await this.writeQueue;
+  }
+
+  private enqueue(event: AgentTraceEvent, filePath: string): void {
+    if (!this.enabled) return;
+    const line = `${JSON.stringify(event)}\n`;
+    this.writeQueue = this.writeQueue
+      .then(async () => {
+        await fs.mkdir(this.traceDir, { recursive: true, mode: 0o700 });
+        await fs.appendFile(filePath, line, { encoding: "utf8", mode: 0o600 });
+        await fs.chmod(filePath, 0o600).catch(() => undefined);
+      })
+      .catch(() => undefined);
+  }
+}
+
+export function summarizeValue(value: unknown): TraceValueSummary {
+  if (typeof value === "string") return summarizeBytes("text", value);
+  if (isBinaryValue(value)) return summarizeBytes("binary", value);
+  const serialized = safeSerialize(value);
+  return summarizeBytes(serialized === undefined ? "unknown" : "json", serialized ?? "");
+}
+
+export function summarizeContent(content: unknown): TraceContentSummary {
+  const items = Array.isArray(content) ? content : [];
+  let textItems = 0;
+  let imageItems = 0;
+  let bytes = 0;
+  const digests: string[] = [];
+  for (const item of items) {
+    if (!isRecord(item)) {
+      digests.push(safeSerialize(item) ?? "unknown");
+      continue;
+    }
+    if (item.type === "text" || item.type === "output_text") {
+      textItems += 1;
+      const text = typeof item.text === "string" ? item.text : "";
+      bytes += Buffer.byteLength(text, "utf8");
+      digests.push(text);
+    } else if (item.type === "image" || item.type === "input_image") {
+      imageItems += 1;
+      const data = typeof item.data === "string" ? item.data : "";
+      bytes += Buffer.byteLength(data, "utf8");
+      digests.push(data);
+    } else {
+      const serialized = safeSerialize(item) ?? "unknown";
+      bytes += Buffer.byteLength(serialized, "utf8");
+      digests.push(serialized);
+    }
+  }
+  return {
+    items: items.length,
+    textItems,
+    imageItems,
+    bytes,
+    sha256: digest(digests.join("\n")),
+  };
+}
+
+export function usageFromPiUsage(usage: {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  totalTokens: number;
+  cost: { total: number };
+}): AgentTraceUsage {
+  return {
+    input: usage.input,
+    output: usage.output,
+    cacheRead: usage.cacheRead,
+    cacheWrite: usage.cacheWrite,
+    total: usage.totalTokens,
+    cost: usage.cost.total,
+  };
+}
+
+export function classifyHttpStatus(status: number): string {
+  if (status === 401 || status === 403) return "auth";
+  if (status === 408 || status === 504) return "timeout";
+  if (status === 429) return "rate_limit";
+  if (status >= 400 && status < 500) return "provider_request";
+  if (status >= 500) return "provider_unavailable";
+  return "unknown";
+}
+
+function summarizeBytes(kind: TraceValueSummary["kind"], value: string | Uint8Array): TraceValueSummary {
+  const bytes = typeof value === "string" ? Buffer.byteLength(value, "utf8") : value.byteLength;
+  return { kind, bytes, sha256: digest(value) };
+}
+
+function digest(value: string | Uint8Array): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function safeSerialize(value: unknown): string | undefined {
+  try {
+    return JSON.stringify(value, (_key, nested) =>
+      typeof nested === "bigint" ? `${nested.toString()}n` : nested,
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+function isBinaryValue(value: unknown): value is Uint8Array {
+  return value instanceof Uint8Array || Buffer.isBuffer(value);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function sanitizeErrorMessage(message: string): string {
+  return message
+    .replace(/https?:\/\/\S+/gi, "<url>")
+    .replace(/(?:sk|key|token|secret)[-_a-z0-9]*\s*[:=]\s*\S+/gi, "<redacted>")
+    .slice(0, 160);
+}
+
+function traceFileTimestamp(timestamp: number): string {
+  return new Date(timestamp).toISOString().replace(/[:.]/g, "-");
+}
diff --git a/packages/core/src/replay.ts b/packages/core/src/replay.ts
new file mode 100644
index 0000000..e31f80e
--- /dev/null
+++ b/packages/core/src/replay.ts
@@ -0,0 +1,303 @@
+import fs from "node:fs/promises";
+import type {
+  AgentTraceEvent,
+  AgentTraceEventType,
+  AgentTraceStatus,
+  AgentTraceUsage,
+} from "./observability.js";
+import { AGENT_TRACE_SCHEMA_VERSION } from "./observability.js";
+
+export interface TraceUsageSummary {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  totalTokens: number;
+  cost: number;
+}
+
+export interface TraceCounts {
+  runs: number;
+  turns: number;
+  modelRequests: number;
+  providerResponses: number;
+  modelResponses: number;
+  toolCalls: number;
+  toolResults: number;
+  toolFailures: number;
+  approvals: number;
+  errors: number;
+  compactions: number;
+}
+
+export interface TraceReplayReport {
+  source?: string;
+  valid: boolean;
+  events: number;
+  invalidLines: number;
+  parseErrors: string[];
+  traceIds: string[];
+  durationMs: number;
+  counts: TraceCounts;
+  usage: TraceUsageSummary;
+  spans: {
+    total: number;
+    closed: number;
+    unclosed: string[];
+  };
+  unmatchedToolCalls: string[];
+  toolNames: string[];
+  missingRunEnds: string[];
+  finalStatus?: AgentTraceStatus;
+  violations: string[];
+}
+
+export interface TraceComparison {
+  baseline: TraceReplayReport;
+  candidate: TraceReplayReport;
+  deltas: Record<string, number>;
+  differences: string[];
+}
+
+const TRACE_EVENT_TYPES = new Set<AgentTraceEventType>([
+  "run_start",
+  "agent_start",
+  "turn_start",
+  "turn_end",
+  "model_request",
+  "provider_response",
+  "model_response",
+  "tool_call",
+  "tool_result",
+  "approval",
+  "compaction",
+  "agent_end",
+  "run_end",
+  "error",
+  "session_shutdown",
+]);
+
+export async function readTraceFile(filePath: string): Promise<TraceReplayReport> {
+  const content = await fs.readFile(filePath, "utf8");
+  return replayTraceLines(content.split(/\r?\n/), filePath);
+}
+
+export function replayTraceLines(lines: string[], source?: string): TraceReplayReport {
+  const events: AgentTraceEvent[] = [];
+  const parseErrors: string[] = [];
+  let invalidLines = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]?.trim();
+    if (!line) continue;
+    try {
+      const value: unknown = JSON.parse(line);
+      if (!isTraceEvent(value)) throw new Error("invalid event envelope");
+      events.push(value);
+    } catch (error) {
+      invalidLines += 1;
+      if (parseErrors.length < 10) {
+        parseErrors.push(`line ${index + 1}: ${error instanceof Error ? error.message : "invalid JSON"}`);
+      }
+    }
+  }
+  return summarizeTrace(events, {
+    ...(source ? { source } : {}),
+    parseErrors,
+    invalidLines,
+  });
+}
+
+export function summarizeTrace(
+  events: AgentTraceEvent[],
+  options: { source?: string; parseErrors?: string[]; invalidLines?: number } = {},
+): TraceReplayReport {
+  const counts: TraceCounts = {
+    runs: 0,
+    turns: 0,
+    modelRequests: 0,
+    providerResponses: 0,
+    modelResponses: 0,
+    toolCalls: 0,
+    toolResults: 0,
+    toolFailures: 0,
+    approvals: 0,
+    errors: 0,
+    compactions: 0,
+  };
+  const usage: TraceUsageSummary = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+    cost: 0,
+  };
+  const traceIds = new Set<string>();
+  const starts = new Map<string, AgentTraceEvent>();
+  const closed = new Set<string>();
+  const toolCalls = new Set<string>();
+  const toolResults = new Set<string>();
+  const toolNames: string[] = [];
+  const runStarts = new Set<string>();
+  const runEnds = new Set<string>();
+  let firstTimestamp: number | undefined;
+  let lastTimestamp: number | undefined;
+  let finalStatus: AgentTraceStatus | undefined;
+
+  for (const event of events) {
+    traceIds.add(event.traceId);
+    const timestamp = Date.parse(event.timestamp);
+    if (Number.isFinite(timestamp)) {
+      firstTimestamp = firstTimestamp === undefined ? timestamp : Math.min(firstTimestamp, timestamp);
+      lastTimestamp = lastTimestamp === undefined ? timestamp : Math.max(lastTimestamp, timestamp);
+    }
+    if (event.status === "started") starts.set(event.spanId, event);
+    if (event.status !== "started") closed.add(event.spanId);
+    addUsage(usage, event.usage);
+    switch (event.type) {
+      case "run_start":
+        counts.runs += 1;
+        runStarts.add(event.runId ?? event.spanId);
+        break;
+      case "turn_start":
+        counts.turns += 1;
+        break;
+      case "model_request":
+        counts.modelRequests += 1;
+        break;
+      case "provider_response":
+        counts.providerResponses += 1;
+        break;
+      case "model_response":
+        counts.modelResponses += 1;
+        break;
+      case "tool_call":
+        counts.toolCalls += 1;
+        if (event.toolName) toolNames.push(event.toolName);
+        if (event.toolCallId) toolCalls.add(event.toolCallId);
+        break;
+      case "tool_result":
+        counts.toolResults += 1;
+        if (event.status === "failed") counts.toolFailures += 1;
+        if (event.toolCallId) toolResults.add(event.toolCallId);
+        break;
+      case "approval":
+        counts.approvals += 1;
+        break;
+      case "error":
+        counts.errors += 1;
+        break;
+      case "compaction":
+        counts.compactions += 1;
+        break;
+      case "run_end":
+        runEnds.add(event.runId ?? event.spanId);
+        finalStatus = event.status;
+        break;
+      default:
+        break;
+    }
+  }
+
+  const unclosed = [...starts.keys()].filter((spanId) => !closed.has(spanId));
+  const unmatchedToolCalls = [...toolCalls].filter((toolCallId) => !toolResults.has(toolCallId));
+  const missingRunEnds = [...runStarts].filter((runId) => !runEnds.has(runId));
+  const parseErrors = options.parseErrors ?? [];
+  const violations = [
+    ...parseErrors.map((error) => `trace parse error: ${error}`),
+    ...(unclosed.length ? [`unclosed spans: ${unclosed.join(", ")}`] : []),
+    ...(unmatchedToolCalls.length
+      ? [`unmatched tool calls: ${unmatchedToolCalls.join(", ")}`]
+      : []),
+    ...(missingRunEnds.length ? [`runs without run_end: ${missingRunEnds.join(", ")}`] : []),
+  ];
+  return {
+    ...(options.source ? { source: options.source } : {}),
+    valid: violations.length === 0,
+    events: events.length,
+    invalidLines: options.invalidLines ?? 0,
+    parseErrors,
+    traceIds: [...traceIds],
+    durationMs:
+      firstTimestamp === undefined || lastTimestamp === undefined
+        ? 0
+        : Math.max(0, lastTimestamp - firstTimestamp),
+    counts,
+    usage,
+    spans: { total: starts.size + [...closed].filter((spanId) => !starts.has(spanId)).length, closed: closed.size, unclosed },
+    unmatchedToolCalls,
+    toolNames,
+    missingRunEnds,
+    ...(finalStatus ? { finalStatus } : {}),
+    violations,
+  };
+}
+
+export function compareTraceReports(
+  baseline: TraceReplayReport,
+  candidate: TraceReplayReport,
+): TraceComparison {
+  const deltas: Record<string, number> = {
+    durationMs: candidate.durationMs - baseline.durationMs,
+    modelRequests: candidate.counts.modelRequests - baseline.counts.modelRequests,
+    modelResponses: candidate.counts.modelResponses - baseline.counts.modelResponses,
+    toolCalls: candidate.counts.toolCalls - baseline.counts.toolCalls,
+    toolFailures: candidate.counts.toolFailures - baseline.counts.toolFailures,
+    errors: candidate.counts.errors - baseline.counts.errors,
+    totalTokens: candidate.usage.totalTokens - baseline.usage.totalTokens,
+    cost: candidate.usage.cost - baseline.usage.cost,
+  };
+  const differences = Object.entries(deltas)
+    .filter(([, value]) => value !== 0)
+    .map(([key, value]) => `${key}: ${formatDelta(value)}`);
+  if (baseline.valid !== candidate.valid) differences.push(`valid: ${String(baseline.valid)} -> ${String(candidate.valid)}`);
+  if (baseline.finalStatus !== candidate.finalStatus) {
+    differences.push(`finalStatus: ${baseline.finalStatus ?? "none"} -> ${candidate.finalStatus ?? "none"}`);
+  }
+  return { baseline, candidate, deltas, differences };
+}
+
+export function formatReplayReport(report: TraceReplayReport, json = false): string {
+  if (json) return JSON.stringify(report, null, 2);
+  return [
+    `Trace ${report.source ?? report.traceIds[0] ?? "unknown"}`,
+    `valid       ${report.valid ? "yes" : "no"}`,
+    `events      ${report.events}`,
+    `duration    ${report.durationMs}ms`,
+    `runs        ${report.counts.runs} (${report.finalStatus ?? "open"})`,
+    `turns       ${report.counts.turns}`,
+    `models      ${report.counts.modelRequests} request(s), ${report.counts.modelResponses} response(s)`,
+    `tools       ${report.counts.toolCalls} call(s), ${report.counts.toolFailures} failure(s)`,
+    `usage       ${report.usage.totalTokens} tokens · $${report.usage.cost.toFixed(4)}`,
+    `spans       ${report.spans.closed}/${report.spans.total} closed`,
+    ...(report.violations.length ? ["violations  ", ...report.violations.map((value) => `  ${value}`)] : []),
+  ].join("\n");
+}
+
+function isTraceEvent(value: unknown): value is AgentTraceEvent {
+  if (typeof value !== "object" || value === null) return false;
+  const event = value as Partial<AgentTraceEvent>;
+  return (
+    event.schemaVersion === AGENT_TRACE_SCHEMA_VERSION &&
+    typeof event.traceId === "string" &&
+    typeof event.spanId === "string" &&
+    typeof event.timestamp === "string" &&
+    Number.isFinite(Date.parse(event.timestamp)) &&
+    typeof event.type === "string" &&
+    TRACE_EVENT_TYPES.has(event.type as AgentTraceEventType)
+  );
+}
+
+function addUsage(summary: TraceUsageSummary, usage: AgentTraceUsage | undefined): void {
+  if (!usage) return;
+  summary.inputTokens += usage.input ?? 0;
+  summary.outputTokens += usage.output ?? 0;
+  summary.cacheReadTokens += usage.cacheRead ?? 0;
+  summary.cacheWriteTokens += usage.cacheWrite ?? 0;
+  summary.totalTokens += usage.total ?? 0;
+  summary.cost += usage.cost ?? 0;
+}
+
+function formatDelta(value: number): string {
+  return Number.isInteger(value) ? (value > 0 ? `+${value}` : String(value)) : `${value > 0 ? "+" : ""}${value.toFixed(4)}`;
+}
diff --git a/packages/core/src/route-profile.ts b/packages/core/src/route-profile.ts
new file mode 100644
index 0000000..b1c64e8
--- /dev/null
+++ b/packages/core/src/route-profile.ts
@@ -0,0 +1,495 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { HarnessMode, PermissionMode } from "./config.js";
+
+export const ROUTE_STATE_ENTRY = "dscode-route-state";
+export const ROUTE_PHASE_ENTRY = "dscode-route-phase";
+export const ROUTE_PROFILE_IDS = [
+  "bootstrap-anchored",
+  "standard-executor",
+  "deep-think",
+  "repair-react",
+] as const;
+
+export type RouteProfileId = (typeof ROUTE_PROFILE_IDS)[number];
+export type RouteSelection = RouteProfileId | "auto";
+export type RouteSource = "auto" | "manual" | "config";
+export type RouteThinkingTarget = "low" | "medium" | "high" | "max";
+export type RoutePhase = "opening" | "working";
+
+export interface RouteState {
+  schemaVersion: 1;
+  profile: RouteProfileId;
+  source: RouteSource;
+  reason: string;
+  confidence: number;
+  thinkingTarget: RouteThinkingTarget;
+  locked: boolean;
+  updatedAt: string;
+}
+
+export interface RoutePhaseState {
+  schemaVersion: 1;
+  profile: RouteProfileId;
+  routeUpdatedAt: string;
+  phase: RoutePhase;
+  turnsStarted: number;
+  updatedAt: string;
+}
+
+export interface RouteSelectionInput {
+  prompt?: unknown;
+  entries?: SessionEntry[];
+  providerId: string;
+  modelId: string;
+  harness: HarnessMode;
+  permission: PermissionMode;
+  projectCommands: string[];
+  now?: () => Date;
+}
+
+const ROUTE_ALIASES: Record<string, RouteSelection> = {
+  auto: "auto",
+  reset: "auto",
+  default: "auto",
+  自动: "auto",
+  重置: "auto",
+  bootstrap: "bootstrap-anchored",
+  anchored: "bootstrap-anchored",
+  anchor: "bootstrap-anchored",
+  minimal: "bootstrap-anchored",
+  锚定: "bootstrap-anchored",
+  探索: "bootstrap-anchored",
+  standard: "standard-executor",
+  executor: "standard-executor",
+  execute: "standard-executor",
+  标准: "standard-executor",
+  执行: "standard-executor",
+  spec: "deep-think",
+  deep: "deep-think",
+  think: "deep-think",
+  planning: "deep-think",
+  plan: "deep-think",
+  深度: "deep-think",
+  思考: "deep-think",
+  规划: "deep-think",
+  repair: "repair-react",
+  react: "repair-react",
+  debug: "repair-react",
+  fix: "repair-react",
+  修复: "repair-react",
+  调试: "repair-react",
+};
+
+const PROFILE_LABELS: Record<RouteProfileId, string> = {
+  "bootstrap-anchored": "bootstrap anchored",
+  "standard-executor": "standard executor",
+  "deep-think": "deep think",
+  "repair-react": "repair react",
+};
+
+export const ROUTE_THINKING_TARGETS: Record<RouteProfileId, RouteThinkingTarget> = {
+  "bootstrap-anchored": "low",
+  "standard-executor": "medium",
+  "deep-think": "max",
+  "repair-react": "high",
+};
+
+const THINKING_RANK: Record<string, number> = {
+  off: 0,
+  minimal: 1,
+  low: 2,
+  medium: 3,
+  high: 4,
+  xhigh: 5,
+  max: 6,
+};
+
+const REPAIR_PATTERNS = [
+  /\bbug\b/u,
+  /\bdebug(?:ging)?\b/u,
+  /\bfix(?:ed|es|ing)?\b/u,
+  /\bfail(?:ed|ing|s|ure)?\b/u,
+  /\berror\b/u,
+  /\bexception\b/u,
+  /\bcrash(?:ed|es|ing)?\b/u,
+  /\bbroken\b/u,
+  /\bregression\b/u,
+  /\bhang(?:s|ing)?\b/u,
+  /\bstuck\b/u,
+  /\bnot working\b/u,
+  /\bdoesn'?t work\b/u,
+  /\bpermission\b/u,
+  /\bapproval\b/u,
+  /修复|报错|错误|失败|崩溃|闪退|卡住|卡死|异常|故障|无法|不工作|有问题|bug/u,
+];
+
+const DEEP_PATTERNS = [
+  /\banaly[sz]e\b/u,
+  /\banalysis\b/u,
+  /\barchitecture\b/u,
+  /\bdesign\b/u,
+  /\bcompare\b/u,
+  /\btrade-?off\b/u,
+  /\bstrategy\b/u,
+  /\broadmap\b/u,
+  /\bproposal\b/u,
+  /\bevaluate\b/u,
+  /\binvestigate\b/u,
+  /\broot cause\b/u,
+  /\brefactor\b/u,
+  /\bmigration\b/u,
+  /\bmulti-?file\b/u,
+  /\bcomplex\b/u,
+  /\bplan\b/u,
+  /分析|架构|设计|方案|对比|权衡|策略|路线图|规划|评估|研究|排查|根因|重构|迁移|复杂|设计草案/u,
+];
+
+const BOOTSTRAP_PATTERNS = [
+  /\bexplore\b/u,
+  /\bsurvey\b/u,
+  /\bunderstand\b/u,
+  /\blook around\b/u,
+  /\bfigure out\b/u,
+  /\bbrainstorm\b/u,
+  /\bwhere should\b/u,
+  /\bhelp me\b/u,
+  /\bstart\b/u,
+  /看一下|看看|先看|先分析|了解|理解|梳理|调研|摸清|搞清楚|从哪里开始/u,
+];
+
+const EXECUTOR_PATTERNS = [
+  /\badd\b/u,
+  /\bchange\b/u,
+  /\bedit\b/u,
+  /\bimplement\b/u,
+  /\bupdate\b/u,
+  /\bremove\b/u,
+  /\bsubmit\b/u,
+  /\bcommit\b/u,
+  /\btest\b/u,
+  /\bbuild\b/u,
+  /实现|修改|改一下|添加|增加|更新|删除|移除|提交|测试|构建|跑一下/u,
+];
+
+export function parseRouteSelection(value: string): RouteSelection | undefined {
+  const normalized = value.trim().toLocaleLowerCase("en-US");
+  if (!normalized) return undefined;
+  if ((ROUTE_PROFILE_IDS as readonly string[]).includes(normalized)) return normalized as RouteProfileId;
+  return ROUTE_ALIASES[normalized];
+}
+
+export function classifyRoute(input: RouteSelectionInput): RouteState {
+  const text = normalizeText(promptText(input.prompt) || latestUserMessageText(input.entries ?? []));
+  const repairScore = score(text, REPAIR_PATTERNS);
+  const deepScore = score(text, DEEP_PATTERNS);
+  const bootstrapScore = score(text, BOOTSTRAP_PATTERNS);
+  const executorScore = score(text, EXECUTOR_PATTERNS);
+  const wordCount = text ? text.split(/\s+/u).filter(Boolean).length : 0;
+  const hasProjectCommands = input.projectCommands.length > 0;
+
+  if (!text) {
+    return createRouteState("standard-executor", "auto", "no user prompt available", 0.4, input.now);
+  }
+  if (repairScore >= 1 && repairScore >= deepScore) {
+    return createRouteState("repair-react", "auto", "repair/debug keywords", Math.min(0.95, 0.65 + repairScore * 0.1), input.now);
+  }
+  if (
+    deepScore >= 2 ||
+    (deepScore >= 1 && bootstrapScore === 0 && executorScore === 0 && repairScore === 0) ||
+    text.length > 900
+  ) {
+    return createRouteState("deep-think", "auto", deepScore >= 1 ? "analysis/design keywords" : "long complex prompt", Math.min(0.9, 0.58 + deepScore * 0.08), input.now);
+  }
+  if (bootstrapScore >= 1 || (wordCount > 0 && wordCount <= 14 && executorScore === 0)) {
+    return createRouteState("bootstrap-anchored", "auto", bootstrapScore >= 1 ? "exploratory bootstrap keywords" : "short ambiguous prompt", Math.min(0.82, 0.55 + bootstrapScore * 0.09), input.now);
+  }
+  if (executorScore >= 1 || hasProjectCommands || input.harness === "minimal") {
+    return createRouteState("standard-executor", "auto", executorScore >= 1 ? "implementation keywords" : "default coding harness", Math.min(0.78, 0.52 + executorScore * 0.07), input.now);
+  }
+  return createRouteState("standard-executor", "auto", "balanced default", 0.5, input.now);
+}
+
+export function createRouteState(
+  profile: RouteProfileId,
+  source: RouteSource,
+  reason: string,
+  confidence = source === "manual" ? 1 : 0.75,
+  now: (() => Date) | undefined = undefined,
+): RouteState {
+  return {
+    schemaVersion: 1,
+    profile,
+    source,
+    reason,
+    confidence,
+    thinkingTarget: routeThinkingTarget(profile),
+    locked: true,
+    updatedAt: (now ?? (() => new Date()))().toISOString(),
+  };
+}
+
+export function restoreRouteState(entries: SessionEntry[]): RouteState | undefined {
+  let restored: RouteState | undefined;
+  for (const entry of entries) {
+    if (entry.type === "custom" && entry.customType === ROUTE_STATE_ENTRY) {
+      restored = normalizeRouteState(entry.data);
+    }
+  }
+  return restored;
+}
+
+export function createRoutePhaseState(
+  route: RouteState,
+  turnsStarted: number,
+  now: (() => Date) | undefined = undefined,
+): RoutePhaseState {
+  return {
+    schemaVersion: 1,
+    profile: route.profile,
+    routeUpdatedAt: route.updatedAt,
+    phase: turnsStarted <= 0 ? "opening" : "working",
+    turnsStarted,
+    updatedAt: (now ?? (() => new Date()))().toISOString(),
+  };
+}
+
+export function restoreRoutePhaseState(entries: SessionEntry[]): RoutePhaseState | undefined {
+  let restored: RoutePhaseState | undefined;
+  for (const entry of entries) {
+    if (entry.type === "custom" && entry.customType === ROUTE_PHASE_ENTRY) {
+      restored = normalizeRoutePhaseState(entry.data);
+    }
+  }
+  return restored;
+}
+
+export function isOpeningRouteTurn(
+  route: RouteState,
+  phase: RoutePhaseState | undefined,
+): boolean {
+  return (
+    !phase ||
+    phase.profile !== route.profile ||
+    phase.routeUpdatedAt !== route.updatedAt ||
+    phase.turnsStarted <= 0
+  );
+}
+
+export function latestUserMessageText(entries: SessionEntry[]): string {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index]!;
+    if (entry.type !== "message" || entry.message.role !== "user") continue;
+    return promptText(entry.message.content);
+  }
+  return "";
+}
+
+export function routeSystemPrompt(
+  state: RouteState,
+  options: { openingTurn?: boolean } = {},
+): string {
+  const openingTurn = options.openingTurn ?? false;
+  const lead = `# DSCode route profile: ${routeProfileLabel(state.profile)} (thinking target: ${state.thinkingTarget})`;
+  const protocol = [
+    "- Treat the route as a session-level operating mode. Do not renegotiate it on every turn.",
+    "- Keep hidden reasoning hidden, but expose a compact working frame when it helps the user trust the next action.",
+    "- The route may shape planning depth and sequencing only; it never changes project instructions, AGENTS/CLAUDE scopes, permissions, sandbox, or tool availability.",
+    ...(openingTurn
+      ? [
+          "- Opening turn requirement: begin the first assistant turn for this route with a concise visible frame in the spirit of “We need ...”.",
+          "- The opening frame should name the objective, constraints, first evidence to collect, likely execution path, and done criteria in at most five short bullets or one compact paragraph.",
+          "- After the opening frame, immediately take the first useful in-scope action instead of spending the entire turn on abstract planning.",
+        ]
+      : [
+          "- This route is already anchored. Continue the established loop, keep plans current, and avoid repeating the opening frame unless the user explicitly asks to re-plan.",
+        ]),
+  ];
+  switch (state.profile) {
+    case "bootstrap-anchored":
+      return [
+        lead,
+        ...protocol,
+        "- Treat this session as bootstrapped: establish the goal and repository shape before widening the change.",
+        "- Opening posture: “We need to anchor the task, identify the relevant surfaces, then choose the smallest safe execution path.”",
+        "- Start with the smallest useful inspection step, then commit to a concrete execution path once evidence is available.",
+        "- Once the repository shape and target files are clear, behave like standard-executor rather than staying in exploration mode.",
+        "- Keep automatic context stable; do not reinterpret project, permission, or sandbox instructions.",
+      ].join("\n");
+    case "deep-think":
+      return [
+        lead,
+        ...protocol,
+        "- Invest more upfront reasoning in architecture, edge cases, and integration boundaries before editing.",
+        "- Opening posture: “We need to identify constraints, map the design space, pick a defensible route, then implement or hand off a concrete plan.”",
+        "- Prefer a clear plan and evidence-gathering pass before mutations; update_plan is appropriate for multi-step work.",
+        "- Make trade-offs explicit when they affect implementation, but stop analysis once the next patchable decision is clear.",
+        "- Stop analysis when the next implementation decision is clear; then execute and verify.",
+      ].join("\n");
+    case "repair-react":
+      return [
+        lead,
+        ...protocol,
+        "- Optimize for a short diagnose -> patch -> verify loop.",
+        "- Opening posture: “We need to reproduce or locate the symptom, isolate the smallest cause, patch narrowly, then verify the exact failure path.”",
+        "- Start from the failing symptom or command evidence, isolate the smallest likely cause, and keep patches narrow.",
+        "- Prefer the most relevant failing check over broad validation until the fix is plausible.",
+        "- Re-run the most relevant failing check after the change before broad validation.",
+      ].join("\n");
+    case "standard-executor":
+      return [
+        lead,
+        ...protocol,
+        "- Use DSCode's balanced coding loop: inspect relevant context, make focused changes, and verify proportionally.",
+        "- Opening posture: “We need to inspect the relevant code path, make the smallest coherent change, then run the narrowest useful check.”",
+        "- Avoid speculative large rewrites unless the user explicitly asks for them or the evidence requires them.",
+        "- Keep momentum: prefer concrete repository progress over elaborate meta-planning.",
+      ].join("\n");
+  }
+}
+
+export function routeProfileLabel(profile: RouteProfileId): string {
+  return PROFILE_LABELS[profile];
+}
+
+export function routeProfileShortLabel(profile: RouteProfileId): string {
+  return profile === "bootstrap-anchored"
+    ? "anchor"
+    : profile === "standard-executor"
+      ? "standard"
+      : profile === "deep-think"
+        ? "deep"
+        : "repair";
+}
+
+export function routeThinkingTarget(profile: RouteProfileId): RouteThinkingTarget {
+  return ROUTE_THINKING_TARGETS[profile];
+}
+
+export function routeThinkingBoost(
+  current: string,
+  profile: RouteProfileId,
+): RouteThinkingTarget | undefined {
+  const target = routeThinkingTarget(profile);
+  const currentRank = THINKING_RANK[current] ?? -1;
+  return currentRank < THINKING_RANK[target]! ? target : undefined;
+}
+
+export function formatRouteStatus(state: RouteState | undefined): string {
+  if (!state) return "auto pending";
+  return `${routeProfileLabel(state.profile)} · ${state.source} · ${Math.round(state.confidence * 100)}% · ${state.reason} · thinking ${state.thinkingTarget}`;
+}
+
+export function formatRoutePhaseStatus(phase: RoutePhaseState | undefined): string {
+  if (!phase) return "opening pending";
+  return `${phase.phase} · turn ${phase.turnsStarted}`;
+}
+
+export function routeCommandUsage(): string {
+  return "Expected /route [auto|bootstrap|standard|deep|repair|status]";
+}
+
+export function routeStateTraceAttributes(
+  state: RouteState,
+): Record<string, string | number | boolean> {
+  return {
+    routeProfile: state.profile,
+    routeSource: state.source,
+    routeReason: state.reason,
+    routeConfidence: Number(state.confidence.toFixed(3)),
+    routeThinkingTarget: state.thinkingTarget,
+    routeLocked: state.locked,
+  };
+}
+
+export function routePhaseTraceAttributes(
+  phase: RoutePhaseState | undefined,
+): Record<string, string | number | boolean> {
+  if (!phase) return { routePhase: "opening", routeTurnsStarted: 0 };
+  return {
+    routePhase: phase.phase,
+    routeTurnsStarted: phase.turnsStarted,
+  };
+}
+
+function score(text: string, patterns: RegExp[]): number {
+  let count = 0;
+  for (const pattern of patterns) {
+    if (pattern.test(text)) count += 1;
+  }
+  return count;
+}
+
+function normalizeText(value: string): string {
+  return value.toLocaleLowerCase("en-US").replace(/\s+/gu, " ").trim();
+}
+
+function promptText(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return "";
+  return value
+    .filter(isRecord)
+    .filter((part) => part.type === "text" && typeof part.text === "string")
+    .map((part) => String(part.text))
+    .join("\n");
+}
+
+function normalizeRouteState(value: unknown): RouteState | undefined {
+  if (
+    !isRecord(value) ||
+    value.schemaVersion !== 1 ||
+    typeof value.profile !== "string" ||
+    !(ROUTE_PROFILE_IDS as readonly string[]).includes(value.profile) ||
+    !["auto", "manual", "config"].includes(String(value.source)) ||
+    typeof value.reason !== "string" ||
+    typeof value.confidence !== "number" ||
+    typeof value.locked !== "boolean" ||
+    typeof value.updatedAt !== "string"
+  ) {
+    return undefined;
+  }
+  const profile = value.profile as RouteProfileId;
+  const thinkingTarget = isRouteThinkingTarget(value.thinkingTarget)
+    ? value.thinkingTarget
+    : routeThinkingTarget(profile);
+  return {
+    schemaVersion: 1,
+    profile,
+    source: value.source as RouteSource,
+    reason: value.reason,
+    confidence: value.confidence,
+    thinkingTarget,
+    locked: value.locked,
+    updatedAt: value.updatedAt,
+  };
+}
+
+function normalizeRoutePhaseState(value: unknown): RoutePhaseState | undefined {
+  if (
+    !isRecord(value) ||
+    value.schemaVersion !== 1 ||
+    typeof value.profile !== "string" ||
+    !(ROUTE_PROFILE_IDS as readonly string[]).includes(value.profile) ||
+    typeof value.routeUpdatedAt !== "string" ||
+    !["opening", "working"].includes(String(value.phase)) ||
+    typeof value.turnsStarted !== "number" ||
+    typeof value.updatedAt !== "string"
+  ) {
+    return undefined;
+  }
+  return {
+    schemaVersion: 1,
+    profile: value.profile as RouteProfileId,
+    routeUpdatedAt: value.routeUpdatedAt,
+    phase: value.phase as RoutePhase,
+    turnsStarted: value.turnsStarted,
+    updatedAt: value.updatedAt,
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isRouteThinkingTarget(value: unknown): value is RouteThinkingTarget {
+  return typeof value === "string" && ["low", "medium", "high", "max"].includes(value);
+}
diff --git a/packages/core/src/runtime-options.ts b/packages/core/src/runtime-options.ts
index 0dcebde..fe0ebdc 100644
--- a/packages/core/src/runtime-options.ts
+++ b/packages/core/src/runtime-options.ts
@@ -23,6 +23,7 @@ import {
   SUPPORTED_PROVIDER_IDS,
   type SupportedProviderId,
 } from "./providers.js";
+import { parseRouteSelection, type RouteSelection } from "./route-profile.js";
 
 export const sandboxModeSchema = z.enum(["read-only", "workspace-write", "danger-full-access"]);
 export type SandboxMode = z.infer<typeof sandboxModeSchema>;
@@ -35,12 +36,15 @@ export interface DSCodeRuntimeOptions {
   transport: ModelTransport;
   harness: HarnessMode;
   permission: PermissionMode;
+  effortExplicit: boolean;
   sandbox: SandboxMode;
   network: boolean;
   webSearch: boolean;
+  route: RouteSelection;
   activeTools: string[];
   toolsExplicit: boolean;
   personalizationFile?: string;
+  fixtureCapturePath?: string;
 }
 
 export interface ParsedRuntimeArgs {
@@ -73,9 +77,11 @@ export function parseRuntimeArgs(argv: string[]): ParsedRuntimeArgs {
   let sandbox = sandboxModeSchema.parse(process.env.DSCODE_SANDBOX ?? "workspace-write");
   let network = false;
   let webSearch = false;
+  let route = parseSelection(process.env.DSCODE_ROUTE ?? "auto", "DSCODE_ROUTE");
   let activeTools: string[] | undefined;
   let toolsExplicit = false;
   const personalizationFile = process.env.DSCODE_PERSONALIZATION_FILE?.trim();
+  let fixtureCapturePath = process.env.DSCODE_FIXTURE_CAPTURE?.trim();
   let help = false;
   let version = false;
   let yolo = false;
@@ -111,6 +117,8 @@ export function parseRuntimeArgs(argv: string[]): ParsedRuntimeArgs {
       network = true;
     } else if (flag === "--web") {
       webSearch = true;
+    } else if (flag === "--route") {
+      route = parseSelection(takeValue(), "--route");
     } else if (flag === "--yes" || flag === "-y") {
       permission = "full";
       yolo = true;
@@ -129,6 +137,8 @@ export function parseRuntimeArgs(argv: string[]): ParsedRuntimeArgs {
     } else if (flag === "--no-tools") {
       activeTools = [];
       toolsExplicit = true;
+    } else if (flag === "--record-fixture") {
+      fixtureCapturePath = path.resolve(takeValue());
     } else if (flag === "--no-resume") {
       // Pi starts a new persisted session unless --continue/--resume is passed.
     } else if (flag === "--help" || flag === "-h") {
@@ -160,9 +170,11 @@ export function parseRuntimeArgs(argv: string[]): ParsedRuntimeArgs {
   }
   modelId ??= defaultModelForProvider(providerId);
   effort ??= defaultEffortForProvider(providerId);
+  const rawThinkingExplicit = hasFlag(forwarded, "--thinking");
+  const thinkingExplicit = effortExplicit || rawThinkingExplicit;
   forwarded.unshift("--provider", providerId);
   if (!hasFlag(forwarded, "--model")) forwarded.unshift("--model", modelId);
-  if (!hasFlag(forwarded, "--thinking")) forwarded.unshift("--thinking", effort);
+  if (!rawThinkingExplicit) forwarded.unshift("--thinking", effort);
   activeTools ??= defaultActiveTools(harness);
 
   return {
@@ -174,12 +186,15 @@ export function parseRuntimeArgs(argv: string[]): ParsedRuntimeArgs {
       transport,
       harness,
       permission,
+      effortExplicit: thinkingExplicit,
       sandbox,
       network,
       webSearch,
+      route,
       activeTools,
       toolsExplicit,
       ...(personalizationFile ? { personalizationFile: path.resolve(personalizationFile) } : {}),
+      ...(fixtureCapturePath ? { fixtureCapturePath: path.resolve(fixtureCapturePath) } : {}),
     },
     piArgs: forwarded,
     help,
@@ -209,6 +224,9 @@ export function printDSCodeHelp(): void {
 
 Usage:
   dscode [options] [prompt]
+  dscode replay <trace.jsonl> [--json]
+  dscode replay --execute <fixture.json> --prompt "task" [--json]
+  dscode evaluate <trace.jsonl> [--json] [budget options]
   dscode -p "task"                 Non-interactive text mode
   dscode --mode json -p "task"     JSONL/CI mode
   dscode --mode rpc                IDE/RPC server
@@ -225,8 +243,10 @@ DSCode options:
   --harness <minimal|safe>         Tool harness (default: minimal)
   --permission <mode>              plan|ask|auto|full (full grants host + network)
   --sandbox <mode>                 read-only|workspace-write|danger-full-access
+  --route <auto|bootstrap|standard|deep|repair>  Session route profile and thinking boost
   --network                        Pre-authorize command network access for this run
   --web                            Enable DeepSeek server-side web search
+  --record-fixture <file>          Explicitly capture assistant responses for offline replay
   -y, --yes                        YOLO: trust project, skip approvals, allow host + network
 
 Session and editor features:
@@ -236,7 +256,13 @@ Session and editor features:
   --mode text|json|rpc, --print, --no-session, --continue, --resume
 
 DSCode commands:
-  /plan /permissions /effort /base-url /status /undo /checkpoints /diff /jobs /mcp /agents /doctor
+  /plan /permissions /effort /route /base-url /status /undo /checkpoints /diff /jobs /mcp /agents /doctor
+
+Runtime traces and evaluation:
+  dscode replay <file> --compare <candidate>  Compare two trace projections
+  dscode replay --execute <fixture> --prompt <task>  Execute a deterministic fixture replay
+  --max-tool-calls <n> --max-duration-ms <n> --max-total-tokens <n> --max-cost <n>
+  --allow-errors                             Do not fail evaluation on runtime errors
 
 Authentication:
   dscode login [provider]           Sign in to a supported model provider
@@ -262,3 +288,9 @@ function splitFlag(argument: string): [string, string | undefined] {
 function hasFlag(args: string[], flag: string): boolean {
   return args.some((argument) => argument === flag || argument.startsWith(`${flag}=`));
 }
+
+function parseSelection(value: string, label: string): RouteSelection {
+  const parsed = parseRouteSelection(value);
+  if (!parsed) throw new Error(`${label} must be auto|bootstrap|standard|deep|repair`);
+  return parsed;
+}
diff --git a/packages/core/src/session-commands.ts b/packages/core/src/session-commands.ts
index af10a4d..850e2c0 100644
--- a/packages/core/src/session-commands.ts
+++ b/packages/core/src/session-commands.ts
@@ -1,4 +1,59 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import fs from "node:fs/promises";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  SessionEntry,
+  SessionHeader,
+} from "@earendil-works/pi-coding-agent";
+
+function isUserMessage(entry: SessionEntry): entry is Extract<SessionEntry, { type: "message" }> {
+  return entry.type === "message" && entry.message.role === "user";
+}
+
+function sessionFileContent(header: SessionHeader | null, entries: SessionEntry[]): string {
+  const fileEntries = header ? [header, ...entries] : entries;
+  return fileEntries.map((entry) => JSON.stringify(entry)).join("\n") + (fileEntries.length > 0 ? "\n" : "");
+}
+
+/**
+ * Replace the active session path in place. Pi sessions are append-only by
+ * design, so rewriting the same file is the only way to remove the abandoned
+ * assistant/tool response without creating a fork or a new session.
+ */
+async function rewriteSessionBeforeEntry(
+  ctx: ExtensionCommandContext,
+  target: Extract<SessionEntry, { type: "message" }>,
+): Promise<boolean> {
+  const sessionFile = ctx.sessionManager.getSessionFile();
+  if (!sessionFile) {
+    const result = await ctx.navigateTree(target.id, { summarize: false });
+    return !result.cancelled;
+  }
+
+  const activePrefix = target.parentId === null
+    ? []
+    : ctx.sessionManager.getBranch(target.parentId);
+  const previousContent = await fs.readFile(sessionFile, "utf8");
+  await fs.writeFile(sessionFile, sessionFileContent(ctx.sessionManager.getHeader(), activePrefix), "utf8");
+  try {
+    const result = await ctx.switchSession(sessionFile);
+    if (result.cancelled) {
+      await fs.writeFile(sessionFile, previousContent, "utf8");
+    }
+    return !result.cancelled;
+  } catch (error) {
+    await fs.writeFile(sessionFile, previousContent, "utf8").catch(() => undefined);
+    throw error;
+  }
+}
+
+async function editLastMessage(ctx: ExtensionCommandContext): Promise<void> {
+  if (!ctx.isIdle()) throw new Error("Wait for the current response to finish before editing the last message.");
+
+  const target = [...ctx.sessionManager.getBranch()].reverse().find(isUserMessage);
+  if (!target) throw new Error("There is no user message to edit.");
+  await rewriteSessionBeforeEntry(ctx, target);
+}
 
 export function registerSessionCommands(pi: ExtensionAPI): void {
   pi.registerCommand("clear", {
@@ -9,4 +64,11 @@ export function registerSessionCommands(pi: ExtensionAPI): void {
       await ctx.newSession();
     },
   });
+
+  pi.registerCommand("edit-last", {
+    description: "Edit and replace the last user message in this session",
+    handler: async (_args, ctx) => {
+      await editLastMessage(ctx);
+    },
+  });
 }
diff --git a/packages/core/src/state.ts b/packages/core/src/state.ts
index f4e38a2..b76c005 100644
--- a/packages/core/src/state.ts
+++ b/packages/core/src/state.ts
@@ -210,6 +210,21 @@ export class DSCodeStateStore {
     return this.get(id);
   }
 
+  async delete(id: string): Promise<boolean> {
+    const current = this.get(id);
+    if (!current) return false;
+
+    // Active sessions can have a compatibility hard link and a partitioned
+    // storage path. Remove each unique path before dropping the index row.
+    const paths = new Set([current.sessionPath, current.storagePath]);
+    for (const file of paths) {
+      await fs.unlink(file).catch((error) => {
+        if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+      });
+    }
+    return this.database.prepare("DELETE FROM threads WHERE id = ?").run(id).changes > 0;
+  }
+
   private async indexFile(
     sessionPath: string,
     storagePath: string,
diff --git a/packages/core/src/status.ts b/packages/core/src/status.ts
index 834f861..5f857d8 100644
--- a/packages/core/src/status.ts
+++ b/packages/core/src/status.ts
@@ -1,6 +1,8 @@
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import type { Usage } from "@earendil-works/pi-ai";
 import type { PermissionMode } from "./config.js";
+import type { RoutePhaseState, RouteState } from "./route-profile.js";
+import { formatRoutePhaseStatus, formatRouteStatus } from "./route-profile.js";
 import { formatCwd } from "./welcome.js";
 
 export interface SessionUsageSummary {
@@ -24,6 +26,8 @@ export interface StatusReportDetails {
   branch?: string | undefined;
   sessionName?: string | undefined;
   sessionFile?: string | undefined;
+  route?: RouteState | undefined;
+  routePhase?: RoutePhaseState | undefined;
   context?: {
     tokens?: number | undefined;
     contextWindow: number;
@@ -76,6 +80,7 @@ export function formatStatusReport(details: StatusReportDetails): string {
     `model      ${details.provider}/${details.model} · ${details.effort} · ${details.transport}`,
     `workspace  ${workspace}`,
     `access     ${details.permission} · ${details.sandbox} · network ${details.network ? "enabled" : "blocked"}`,
+    `route      ${formatRouteStatus(details.route)} · ${formatRoutePhaseStatus(details.routePhase)}`,
     `context    ${context}`,
     `cache      ${cache}`,
     `tokens     ${formatTokenCount(usage.input)} uncached input · ${formatTokenCount(usage.output)} output`,
diff --git a/packages/core/src/subagents.ts b/packages/core/src/subagents.ts
index 8970c04..caf612c 100644
--- a/packages/core/src/subagents.ts
+++ b/packages/core/src/subagents.ts
@@ -163,6 +163,8 @@ Return concise evidence, exact file paths, commands/checks, and any unresolved r
     readOnly ? "read-only" : "workspace-write",
     "--thinking",
     role === "explorer" ? "low" : "max",
+    "--route",
+    runtime.route,
     ...(runtime.network ? ["--network"] : []),
     ...(runtime.webSearch ? ["--web"] : []),
     rolePrompt,
diff --git a/packages/core/src/ui.ts b/packages/core/src/ui.ts
index e017cf5..bae55bc 100644
--- a/packages/core/src/ui.ts
+++ b/packages/core/src/ui.ts
@@ -115,6 +115,7 @@ export function printHelp(): void {
       "/plan       Toggle read-only plan mode",
       "/permissions [mode]  Show or set plan/ask/auto/full",
       "/effort [level]      Show or set low/high/max",
+      "/route [profile]     Show or set auto/bootstrap/standard/deep/repair",
       "/status     Show model, workspace, and context size",
       "/exit       Save and quit",
       "",
diff --git a/test/access-integration.test.ts b/test/access-integration.test.ts
index a89dd79..100bd4f 100644
--- a/test/access-integration.test.ts
+++ b/test/access-integration.test.ts
@@ -84,9 +84,11 @@ function options(cwd: string): DSCodeRuntimeOptions {
     transport: "responses",
     harness: "minimal",
     permission: "auto",
+    effortExplicit: false,
     sandbox: "workspace-write",
     network: false,
     webSearch: false,
+    route: "auto",
     activeTools: ["update_plan", "exec_command", "write_stdin", "apply_patch"],
     toolsExplicit: false,
   };
diff --git a/test/cli-integration.test.ts b/test/cli-integration.test.ts
index 89c2072..f67a650 100644
--- a/test/cli-integration.test.ts
+++ b/test/cli-integration.test.ts
@@ -1,10 +1,14 @@
+import fs from "node:fs/promises";
 import { spawn } from "node:child_process";
 import http from "node:http";
+import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
+import { readAgentFixtureFile, writeAgentFixture } from "../packages/core/src/fixture.js";
 
 describe("DSCode Pi integration", () => {
   let server: http.Server | undefined;
+  let traceDir: string | undefined;
 
   afterEach(async () => {
     if (!server) return;
@@ -12,9 +16,13 @@ describe("DSCode Pi integration", () => {
       server!.close((error) => (error ? reject(error) : resolve())),
     );
     server = undefined;
+    if (traceDir) await fs.rm(traceDir, { recursive: true, force: true });
+    traceDir = undefined;
   });
 
   it("runs a JSONL turn through the DeepSeek Responses adapter", async () => {
+    traceDir = await fs.mkdtemp(path.join(os.tmpdir(), "dscode-cli-trace-"));
+    const fixturePath = path.join(traceDir, "recorded.json");
     let payload: Record<string, any> | undefined;
     server = http.createServer(async (request, response) => {
       const body: Buffer[] = [];
@@ -91,6 +99,8 @@ describe("DSCode Pi integration", () => {
         "--print",
         "--no-session",
         "--no-approve",
+        "--record-fixture",
+        fixturePath,
         "reply once",
       ],
       {
@@ -100,6 +110,7 @@ describe("DSCode Pi integration", () => {
         DEEPSEEK_API_KEY: "test-only-key",
         PI_SKIP_VERSION_CHECK: "1",
         PI_TELEMETRY: "0",
+        DSCODE_TRACE_DIR: traceDir,
       },
     );
 
@@ -115,9 +126,26 @@ describe("DSCode Pi integration", () => {
         expect.objectContaining({ type: "custom", name: "apply_patch" }),
       ]),
     );
+    const traceFiles = (await fs.readdir(traceDir)).filter((file) => file.endsWith(".jsonl"));
+    expect(traceFiles).toHaveLength(1);
+    const trace = await fs.readFile(path.join(traceDir, traceFiles[0]!), "utf8");
+    const events = trace
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line) as { type: string });
+    expect(events.map((event) => event.type)).toEqual(
+      expect.arrayContaining(["run_start", "model_request", "provider_response", "model_response", "run_end"]),
+    );
+    expect(await readAgentFixtureFile(fixturePath)).toMatchObject({
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      responses: [{ content: [{ type: "text", text: "mock response" }], stopReason: "stop" }],
+    });
+    expect((await fs.stat(fixturePath)).mode & 0o777).toBe(0o600);
   }, 15_000);
 
   it("returns a non-zero CI exit code on provider failure", async () => {
+    traceDir = await fs.mkdtemp(path.join(os.tmpdir(), "dscode-cli-error-trace-"));
     server = http.createServer(async (_request, response) => {
       response.writeHead(401, { "content-type": "application/json" });
       response.end(JSON.stringify({ error: { message: "invalid test key" } }));
@@ -144,12 +172,209 @@ describe("DSCode Pi integration", () => {
         DEEPSEEK_API_KEY: "invalid-test-key",
         PI_SKIP_VERSION_CHECK: "1",
         PI_TELEMETRY: "0",
+        DSCODE_TRACE_DIR: traceDir,
       },
     );
 
     expect(execution.exitCode).not.toBe(0);
     expect(`${execution.stdout}\n${execution.stderr}`).toContain("invalid test key");
+    const traceFiles = (await fs.readdir(traceDir)).filter((file) => file.endsWith(".jsonl"));
+    expect(traceFiles).toHaveLength(1);
+    const traceLines = (await fs.readFile(path.join(traceDir, traceFiles[0]!), "utf8"))
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line) as { type: string; status?: string });
+    expect(traceLines).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ type: "error" }),
+        expect.objectContaining({ type: "run_end", status: "failed" }),
+      ]),
+    );
+  }, 15_000);
+
+  it("rejects fixture execution on evaluate", async () => {
+    const execution = await spawnCapture(
+      process.execPath,
+      [
+        path.resolve("node_modules/tsx/dist/cli.mjs"),
+        "src/cli.ts",
+        "evaluate",
+        "--execute",
+        "ignored-fixture.json",
+        "--json",
+      ],
+      {
+        ...process.env,
+        PI_SKIP_VERSION_CHECK: "1",
+        PI_TELEMETRY: "0",
+      },
+    );
+
+    expect(execution.exitCode).not.toBe(0);
+    expect(execution.stderr).toContain("--execute is only supported by replay");
   }, 15_000);
+
+  it("executes a deterministic fixture through the real agent runtime", async () => {
+    const fixtureDir = await fs.mkdtemp(path.join(os.tmpdir(), "dscode-execute-fixture-"));
+    const fixturePath = path.join(fixtureDir, "case.json");
+    await writeAgentFixture(fixturePath, {
+      schemaVersion: 1,
+      kind: "dscode-agent-fixture",
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      responses: [
+        { content: [{ type: "text", text: "fixture response" }], stopReason: "stop" },
+      ],
+      assertions: { finalStatus: "completed", modelResponses: 1 },
+    });
+    const execution = await spawnCapture(
+      process.execPath,
+      [
+        path.resolve("node_modules/tsx/dist/cli.mjs"),
+        "src/cli.ts",
+        "replay",
+        "--execute",
+        fixturePath,
+        "--prompt",
+        "reply once",
+        "--json",
+      ],
+      {
+        ...process.env,
+        DSCODE_TRACE: "0",
+        PI_SKIP_VERSION_CHECK: "1",
+        PI_TELEMETRY: "0",
+      },
+    );
+    await fs.rm(fixtureDir, { recursive: true, force: true });
+
+    expect(execution.exitCode, execution.stderr).toBe(0);
+    const result = JSON.parse(execution.stdout) as {
+      passed: boolean;
+      modelRequests: number;
+      modelResponses: number;
+      violations: string[];
+    };
+    expect(result).toMatchObject({
+      passed: true,
+      modelRequests: 1,
+      modelResponses: 1,
+      violations: [],
+    });
+  }, 15_000);
+
+  it("replays fixture tool calls through the real tool loop", async () => {
+    const fixtureDir = await fs.mkdtemp(path.join(os.tmpdir(), "dscode-tool-fixture-"));
+    const fixturePath = path.join(fixtureDir, "case.json");
+    await writeAgentFixture(fixturePath, {
+      schemaVersion: 1,
+      kind: "dscode-agent-fixture",
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      responses: [
+        {
+          content: [
+            {
+              type: "toolCall",
+              id: "call-fixture-1",
+              name: "exec_command",
+              arguments: { cmd: "printf fixture-tool" },
+            },
+          ],
+          stopReason: "toolUse",
+        },
+        { content: [{ type: "text", text: "tool completed" }], stopReason: "stop" },
+      ],
+      assertions: {
+        finalStatus: "completed",
+        toolNames: ["exec_command"],
+        modelResponses: 2,
+      },
+    });
+    const execution = await spawnCapture(
+      process.execPath,
+      [
+        path.resolve("node_modules/tsx/dist/cli.mjs"),
+        "src/cli.ts",
+        "replay",
+        "--execute",
+        fixturePath,
+        "--prompt",
+        "run the fixture tool",
+        "--json",
+      ],
+      {
+        ...process.env,
+        DSCODE_TRACE: "0",
+        PI_SKIP_VERSION_CHECK: "1",
+        PI_TELEMETRY: "0",
+      },
+    );
+    await fs.rm(fixtureDir, { recursive: true, force: true });
+
+    expect(execution.exitCode, execution.stderr).toBe(0);
+    const result = JSON.parse(execution.stdout) as {
+      passed: boolean;
+      modelResponses: number;
+      violations: string[];
+    };
+    expect(result).toMatchObject({
+      passed: true,
+      modelResponses: 2,
+      violations: [],
+    });
+  }, 15_000);
+
+  it("allows an explicitly expected fixture error", async () => {
+    const fixtureDir = await fs.mkdtemp(path.join(os.tmpdir(), "dscode-error-fixture-"));
+    const fixturePath = path.join(fixtureDir, "case.json");
+    await writeAgentFixture(fixturePath, {
+      schemaVersion: 1,
+      kind: "dscode-agent-fixture",
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      responses: [
+        { content: [], stopReason: "error", errorMessage: "fixture rate limit" },
+        { content: [], stopReason: "error", errorMessage: "fixture rate limit" },
+        { content: [], stopReason: "error", errorMessage: "fixture rate limit" },
+        { content: [], stopReason: "error", errorMessage: "fixture rate limit" },
+      ],
+      evaluation: { requireSuccessfulRun: false, failOnErrors: false },
+      assertions: { finalStatus: "failed", modelResponses: 4 },
+    });
+    const execution = await spawnCapture(
+      process.execPath,
+      [
+        path.resolve("node_modules/tsx/dist/cli.mjs"),
+        "src/cli.ts",
+        "replay",
+        "--execute",
+        fixturePath,
+        "--prompt",
+        "exercise the error path",
+        "--json",
+      ],
+      {
+        ...process.env,
+        DSCODE_TRACE: "0",
+        PI_SKIP_VERSION_CHECK: "1",
+        PI_TELEMETRY: "0",
+      },
+    );
+    await fs.rm(fixtureDir, { recursive: true, force: true });
+
+    expect(execution.exitCode, `${execution.stderr}\n${execution.stdout}`).toBe(0);
+    const result = JSON.parse(execution.stdout) as {
+      passed: boolean;
+      modelResponses: number;
+      violations: string[];
+    };
+    expect(result).toMatchObject({
+      passed: true,
+      modelResponses: 4,
+      violations: [],
+    });
+  }, 30_000);
 });
 
 function sendEvent(response: http.ServerResponse, event: Record<string, unknown>): void {
diff --git a/test/deepseek-provider.test.ts b/test/deepseek-provider.test.ts
index 81a78c8..72d57dd 100644
--- a/test/deepseek-provider.test.ts
+++ b/test/deepseek-provider.test.ts
@@ -45,9 +45,11 @@ function options(): DSCodeRuntimeOptions {
     transport: "responses",
     harness: "minimal",
     permission: "auto",
+    effortExplicit: false,
     sandbox: "workspace-write",
     network: false,
     webSearch: false,
+    route: "auto",
     activeTools: ["update_plan", "exec_command", "write_stdin", "apply_patch"],
     toolsExplicit: false,
   };
diff --git a/test/fixture.test.ts b/test/fixture.test.ts
new file mode 100644
index 0000000..32602ec
--- /dev/null
+++ b/test/fixture.test.ts
@@ -0,0 +1,138 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  AGENT_FIXTURE_KIND,
+  AGENT_FIXTURE_SCHEMA_VERSION,
+  AgentFixtureReplay,
+  readAgentFixtureFile,
+  writeAgentFixture,
+  type AgentFixture,
+} from "../packages/core/src/fixture.js";
+import type { Model } from "@earendil-works/pi-ai";
+
+describe("agent fixtures", () => {
+  it("round-trips a fixture with tool calls and streams deterministic responses", async () => {
+    const directory = await fs.mkdtemp(path.join(os.tmpdir(), "dscode-fixture-"));
+    const fixturePath = path.join(directory, "case.json");
+    const fixture: AgentFixture = {
+      schemaVersion: AGENT_FIXTURE_SCHEMA_VERSION,
+      kind: AGENT_FIXTURE_KIND,
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      responses: [
+        {
+          content: [
+            {
+              type: "toolCall",
+              id: "call-1",
+              name: "exec_command",
+              arguments: { cmd: "printf fixture" },
+            },
+          ],
+          stopReason: "toolUse",
+        },
+        { content: [{ type: "text", text: "fixture complete" }], stopReason: "stop" },
+      ],
+      assertions: { finalStatus: "completed", toolNames: ["exec_command"], modelResponses: 2 },
+    };
+    await writeAgentFixture(fixturePath, fixture);
+    const loaded = await readAgentFixtureFile(fixturePath);
+    expect(loaded).toEqual(fixture);
+
+    const replay = new AgentFixtureReplay(loaded);
+    const model = {
+      api: "dscode-fixture",
+      provider: "deepseek",
+      id: "deepseek-v4-flash",
+    } as Model<"dscode-fixture">;
+    const first = replay.stream(model, { messages: [] });
+    const firstEvents = [];
+    for await (const event of first) firstEvents.push(event);
+    expect(firstEvents.at(-1)).toMatchObject({ type: "done", reason: "toolUse" });
+    expect(await first.result()).toMatchObject({
+      stopReason: "toolUse",
+      content: [{ type: "toolCall", name: "exec_command" }],
+    });
+    expect(replay.consumedResponses()).toBe(1);
+    await fs.rm(directory, { recursive: true, force: true });
+  });
+
+  it("turns an error fixture response into an assistant error event", async () => {
+    const fixture: AgentFixture = {
+      schemaVersion: AGENT_FIXTURE_SCHEMA_VERSION,
+      kind: AGENT_FIXTURE_KIND,
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      responses: [
+        {
+          content: [],
+          stopReason: "error",
+          errorMessage: "fixture rate limit",
+        },
+      ],
+    };
+    const replay = new AgentFixtureReplay(fixture);
+    const model = {
+      api: "dscode-fixture",
+      provider: "deepseek",
+      id: "deepseek-v4-flash",
+    } as Model<"dscode-fixture">;
+    const stream = replay.stream(model, { messages: [] });
+    const events = [];
+    for await (const event of stream) events.push(event);
+    expect(events.at(-1)).toMatchObject({ type: "error", reason: "error" });
+    expect(await stream.result()).toMatchObject({ stopReason: "error", errorMessage: "fixture rate limit" });
+  });
+
+  it("injects response delays and aborted responses", async () => {
+    const fixture: AgentFixture = {
+      schemaVersion: AGENT_FIXTURE_SCHEMA_VERSION,
+      kind: AGENT_FIXTURE_KIND,
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      responses: [
+        { content: [], stopReason: "aborted", delayMs: 10, errorMessage: "fixture cancelled" },
+      ],
+    };
+    const replay = new AgentFixtureReplay(fixture);
+    const model = {
+      api: "dscode-fixture",
+      provider: "deepseek",
+      id: "deepseek-v4-flash",
+    } as Model<"dscode-fixture">;
+    const started = Date.now();
+    const stream = replay.stream(model, { messages: [] });
+    expect(await stream.result()).toMatchObject({
+      stopReason: "aborted",
+      errorMessage: "fixture cancelled",
+    });
+    expect(Date.now() - started).toBeGreaterThanOrEqual(1);
+  });
+
+  it("preserves an abort raised while a response is delayed", async () => {
+    const fixture: AgentFixture = {
+      schemaVersion: AGENT_FIXTURE_SCHEMA_VERSION,
+      kind: AGENT_FIXTURE_KIND,
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      responses: [
+        { content: [{ type: "text", text: "late" }], stopReason: "stop", delayMs: 50 },
+      ],
+    };
+    const replay = new AgentFixtureReplay(fixture);
+    const model = {
+      api: "dscode-fixture",
+      provider: "deepseek",
+      id: "deepseek-v4-flash",
+    } as Model<"dscode-fixture">;
+    const controller = new AbortController();
+    const stream = replay.stream(model, { messages: [] }, { signal: controller.signal });
+    queueMicrotask(() => controller.abort());
+    const events = [];
+    for await (const event of stream) events.push(event);
+    expect(events.at(-1)).toMatchObject({ type: "error", reason: "aborted" });
+    expect(await stream.result()).toMatchObject({ stopReason: "aborted" });
+  });
+});
diff --git a/test/observability.test.ts b/test/observability.test.ts
new file mode 100644
index 0000000..41d414b
--- /dev/null
+++ b/test/observability.test.ts
@@ -0,0 +1,142 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { AgentRuntimeTrace, summarizeValue } from "../packages/core/src/observability.js";
+import { evaluateTrace } from "../packages/core/src/evaluation.js";
+import { readTraceFile, replayTraceLines } from "../packages/core/src/replay.js";
+
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    temporaryDirectories.splice(0).map((directory) => fs.rm(directory, { recursive: true, force: true })),
+  );
+});
+
+describe("agent runtime observability", () => {
+  it("writes a redacted, replayable JSONL trace without blocking record calls", async () => {
+    const directory = await fs.mkdtemp(path.join(os.tmpdir(), "dscode-trace-"));
+    temporaryDirectories.push(directory);
+    let timestamp = 1_700_000_000_000;
+    const ids = ["trace-1", "run-1"];
+    const trace = new AgentRuntimeTrace({
+      traceDir: directory,
+      now: () => new Date(timestamp += 10),
+      createId: () => ids.shift() ?? "generated-id",
+    });
+    trace.setSession("session-1");
+    trace.startRun({ provider: "deepseek", model: "test-model" });
+    trace.record({
+      type: "agent_start",
+      spanId: "agent:run-1",
+      status: "started",
+      input: summarizeValue("api_key=do-not-store-this"),
+    });
+    trace.record({
+      type: "model_request",
+      spanId: "model:1",
+      status: "started",
+      input: summarizeValue({ prompt: "private prompt" }),
+    });
+    trace.record({
+      type: "model_response",
+      spanId: "model:1",
+      status: "completed",
+      usage: { input: 10, output: 4, total: 14, cost: 0.002 },
+    });
+    trace.record({
+      type: "tool_call",
+      spanId: "tool:1",
+      status: "started",
+      toolCallId: "call-1",
+      toolName: "read_file",
+      input: summarizeValue({ path: "/private/file.txt" }),
+    });
+    trace.record({
+      type: "tool_result",
+      spanId: "tool:1",
+      status: "completed",
+      toolCallId: "call-1",
+      toolName: "read_file",
+      output: summarizeValue("private file contents"),
+    });
+    trace.record({ type: "agent_end", spanId: "agent:run-1", status: "completed" });
+    trace.endRun("completed");
+    await trace.flush();
+
+    const tracePath = trace.getTracePath();
+    expect(tracePath).toBeDefined();
+    const raw = await fs.readFile(tracePath!, "utf8");
+    expect(raw).not.toContain("private prompt");
+    expect(raw).not.toContain("private file contents");
+    expect(raw).not.toContain("do-not-store-this");
+
+    const report = await readTraceFile(tracePath!);
+    expect(report.valid).toBe(true);
+    expect(report.counts.modelRequests).toBe(1);
+    expect(report.counts.toolCalls).toBe(1);
+    expect(report.counts.toolFailures).toBe(0);
+    expect(report.usage.totalTokens).toBe(14);
+    expect(report.usage.cost).toBe(0.002);
+  });
+
+  it("reports malformed and structurally incomplete traces", () => {
+    const report = replayTraceLines([
+      JSON.stringify({
+        schemaVersion: 1,
+        traceId: "trace-1",
+        runId: "run-1",
+        spanId: "run:run-1",
+        timestamp: new Date().toISOString(),
+        type: "run_start",
+        status: "started",
+      }),
+      JSON.stringify({
+        schemaVersion: 1,
+        traceId: "trace-1",
+        runId: "run-1",
+        spanId: "tool:call-1",
+        timestamp: new Date().toISOString(),
+        type: "tool_call",
+        status: "started",
+        toolCallId: "call-1",
+      }),
+      "not-json",
+    ]);
+
+    expect(report.valid).toBe(false);
+    expect(report.invalidLines).toBe(1);
+    expect(report.unmatchedToolCalls).toEqual(["call-1"]);
+    expect(report.missingRunEnds).toEqual(["run-1"]);
+    expect(report.violations.join("\n")).toContain("trace parse error");
+  });
+
+  it("evaluates success and budget constraints from the same event projection", () => {
+    const timestamp = new Date().toISOString();
+    const events = [
+      {
+        schemaVersion: 1 as const,
+        traceId: "trace-1",
+        runId: "run-1",
+        spanId: "run:run-1",
+        timestamp,
+        type: "run_start" as const,
+        status: "started" as const,
+      },
+      {
+        schemaVersion: 1 as const,
+        traceId: "trace-1",
+        runId: "run-1",
+        spanId: "run:run-1",
+        timestamp,
+        type: "run_end" as const,
+        status: "completed" as const,
+      },
+    ];
+    const result = evaluateTrace(events, { maxToolCalls: 0 });
+    expect(result.passed).toBe(true);
+    expect(result.violations).toEqual([]);
+    expect(evaluateTrace(events, { maxToolCalls: -1 }).passed).toBe(false);
+  });
+});
diff --git a/test/route-profile.test.ts b/test/route-profile.test.ts
new file mode 100644
index 0000000..6968e5d
--- /dev/null
+++ b/test/route-profile.test.ts
@@ -0,0 +1,151 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import { describe, expect, it } from "vitest";
+import {
+  classifyRoute,
+  createRoutePhaseState,
+  createRouteState,
+  formatRoutePhaseStatus,
+  isOpeningRouteTurn,
+  parseRouteSelection,
+  restoreRoutePhaseState,
+  restoreRouteState,
+  routeSystemPrompt,
+  routeThinkingBoost,
+  routeThinkingTarget,
+  ROUTE_PHASE_ENTRY,
+  ROUTE_STATE_ENTRY,
+} from "../packages/core/src/route-profile.js";
+
+const now = (): Date => new Date("2026-08-17T00:00:00.000Z");
+
+function classify(prompt: string) {
+  return classifyRoute({
+    prompt,
+    entries: [],
+    providerId: "deepseek",
+    modelId: "deepseek-v4-flash",
+    harness: "minimal",
+    permission: "auto",
+    projectCommands: [],
+    now,
+  });
+}
+
+describe("route profile selection", () => {
+  it("routes repair and debugging requests to repair-react", () => {
+    expect(classify("修复这个报错，发送后会崩溃").profile).toBe("repair-react");
+    expect(classify("debug this failing regression").profile).toBe("repair-react");
+  });
+
+  it("routes design and analysis requests to deep-think", () => {
+    expect(classify("给我拆一个设计草案，分析架构权衡").profile).toBe("deep-think");
+    expect(classify("compare the architecture trade-offs").profile).toBe("deep-think");
+  });
+
+  it("keeps exploratory short prompts anchored", () => {
+    expect(classify("先看一下这个项目").profile).toBe("bootstrap-anchored");
+    expect(classify("where should we start?").profile).toBe("bootstrap-anchored");
+  });
+
+  it("routes implementation requests to the standard executor", () => {
+    expect(classify("实现这个功能并跑一下测试").profile).toBe("standard-executor");
+    expect(classify("add tests and build").profile).toBe("standard-executor");
+  });
+
+  it("parses friendly route aliases", () => {
+    expect(parseRouteSelection("auto")).toBe("auto");
+    expect(parseRouteSelection("bootstrap")).toBe("bootstrap-anchored");
+    expect(parseRouteSelection("标准")).toBe("standard-executor");
+    expect(parseRouteSelection("deep")).toBe("deep-think");
+    expect(parseRouteSelection("修复")).toBe("repair-react");
+    expect(parseRouteSelection("unknown")).toBeUndefined();
+  });
+
+  it("restores the latest persisted route state", () => {
+    const first = createRouteState("standard-executor", "auto", "first", 0.5, now);
+    const second = createRouteState("deep-think", "manual", "manual override", 1, now);
+    const entries = [
+      { type: "custom", customType: ROUTE_STATE_ENTRY, data: first },
+      { type: "custom", customType: "other", data: { ignored: true } },
+      { type: "custom", customType: ROUTE_STATE_ENTRY, data: second },
+    ] as unknown as SessionEntry[];
+
+    expect(restoreRouteState(entries)).toEqual(second);
+  });
+
+  it("normalizes older route state entries without thinking targets", () => {
+    const entries = [
+      {
+        type: "custom",
+        customType: ROUTE_STATE_ENTRY,
+        data: {
+          schemaVersion: 1,
+          profile: "deep-think",
+          source: "auto",
+          reason: "legacy",
+          confidence: 0.8,
+          locked: true,
+          updatedAt: "2026-08-17T00:00:00.000Z",
+        },
+      },
+    ] as unknown as SessionEntry[];
+
+    expect(restoreRouteState(entries)).toMatchObject({
+      profile: "deep-think",
+      thinkingTarget: "max",
+    });
+  });
+
+  it("tracks opening versus working route phases", () => {
+    const route = createRouteState("deep-think", "auto", "analysis/design keywords", 0.8, now);
+    const opening = createRoutePhaseState(route, 0, now);
+    const working = createRoutePhaseState(route, 1, now);
+
+    expect(isOpeningRouteTurn(route, undefined)).toBe(true);
+    expect(isOpeningRouteTurn(route, opening)).toBe(true);
+    expect(isOpeningRouteTurn(route, working)).toBe(false);
+    expect(formatRoutePhaseStatus(opening)).toBe("opening · turn 0");
+    expect(formatRoutePhaseStatus(working)).toBe("working · turn 1");
+  });
+
+  it("restores the latest persisted route phase state", () => {
+    const route = createRouteState("repair-react", "manual", "manual override", 1, now);
+    const phase = createRoutePhaseState(route, 2, now);
+    const entries = [
+      { type: "custom", customType: ROUTE_PHASE_ENTRY, data: createRoutePhaseState(route, 1, now) },
+      { type: "custom", customType: ROUTE_PHASE_ENTRY, data: phase },
+    ] as unknown as SessionEntry[];
+
+    expect(restoreRoutePhaseState(entries)).toEqual(phase);
+  });
+
+  it("adds a strong opening frame without replacing safety or project instructions", () => {
+    const prompt = routeSystemPrompt(
+      createRouteState("repair-react", "auto", "repair/debug keywords", 0.75, now),
+      { openingTurn: true },
+    );
+    expect(prompt).toContain("DSCode route profile: repair react (thinking target: high)");
+    expect(prompt).toContain("Opening turn requirement");
+    expect(prompt).toContain("We need");
+    expect(prompt).toContain("diagnose -> patch -> verify");
+  });
+
+  it("keeps later turns anchored without repeating the opening frame", () => {
+    const prompt = routeSystemPrompt(
+      createRouteState("standard-executor", "auto", "implementation keywords", 0.75, now),
+      { openingTurn: false },
+    );
+    expect(prompt).toContain("This route is already anchored");
+    expect(prompt).not.toContain("Opening turn requirement");
+  });
+
+  it("maps profiles to thinking targets and boosts only upward", () => {
+    expect(routeThinkingTarget("bootstrap-anchored")).toBe("low");
+    expect(routeThinkingTarget("standard-executor")).toBe("medium");
+    expect(routeThinkingTarget("repair-react")).toBe("high");
+    expect(routeThinkingTarget("deep-think")).toBe("max");
+    expect(routeThinkingBoost("low", "deep-think")).toBe("max");
+    expect(routeThinkingBoost("max", "deep-think")).toBeUndefined();
+    expect(routeThinkingBoost("medium", "bootstrap-anchored")).toBeUndefined();
+  });
+});
diff --git a/test/runtime-options.test.ts b/test/runtime-options.test.ts
index cd040ea..216289a 100644
--- a/test/runtime-options.test.ts
+++ b/test/runtime-options.test.ts
@@ -10,6 +10,7 @@ describe("parseRuntimeArgs", () => {
     harness: process.env.DSCODE_HARNESS,
     permission: process.env.DSCODE_PERMISSION,
     sandbox: process.env.DSCODE_SANDBOX,
+    route: process.env.DSCODE_ROUTE,
   };
 
   beforeEach(() => {
@@ -24,6 +25,7 @@ describe("parseRuntimeArgs", () => {
     restore("DSCODE_HARNESS", original.harness);
     restore("DSCODE_PERMISSION", original.permission);
     restore("DSCODE_SANDBOX", original.sandbox);
+    restore("DSCODE_ROUTE", original.route);
   });
 
   it("injects the DeepSeek provider, max thinking, and selects minimal agent tools", () => {
@@ -33,6 +35,7 @@ describe("parseRuntimeArgs", () => {
     delete process.env.DSCODE_HARNESS;
     delete process.env.DSCODE_PERMISSION;
     delete process.env.DSCODE_SANDBOX;
+    delete process.env.DSCODE_ROUTE;
     const parsed = parseRuntimeArgs(["--print", "inspect this repo"]);
 
     expect(parsed.options).toMatchObject({
@@ -41,7 +44,9 @@ describe("parseRuntimeArgs", () => {
       transport: "responses",
       harness: "minimal",
       permission: "auto",
+      effortExplicit: false,
       sandbox: "workspace-write",
+      route: "auto",
       activeTools: ["update_plan", "exec_command", "write_stdin", "apply_patch", "delegate"],
       toolsExplicit: false,
     });
@@ -118,6 +123,7 @@ describe("parseRuntimeArgs", () => {
     expect(parsed.options).toMatchObject({
       harness: "safe",
       permission: "ask",
+      effortExplicit: true,
       sandbox: "read-only",
       activeTools: [
         "update_plan",
@@ -144,6 +150,22 @@ describe("parseRuntimeArgs", () => {
     expect(parsed.piArgs).not.toContain("--tools");
   });
 
+  it("parses route profile flags and environment aliases", () => {
+    process.env.DSCODE_ROUTE = "repair";
+    expect(parseRuntimeArgs([]).options.route).toBe("repair-react");
+    expect(parseRuntimeArgs(["--route", "deep"]).options.route).toBe("deep-think");
+    expect(parseRuntimeArgs(["--route=标准"]).options.route).toBe("standard-executor");
+    expect(() => parseRuntimeArgs(["--route", "mystery"])).toThrow(
+      "--route must be auto|bootstrap|standard|deep|repair",
+    );
+  });
+
+  it("treats forwarded thinking flags as explicit effort", () => {
+    const parsed = parseRuntimeArgs(["--thinking", "low", "--print", "inspect"]);
+    expect(parsed.options.effortExplicit).toBe(true);
+    expect(parsed.piArgs).toEqual(expect.arrayContaining(["--thinking", "low"]));
+  });
+
   it("maps YOLO mode to full access and one-run project trust", () => {
     const parsed = parseRuntimeArgs(["-y"]);
     expect(parsed.options.permission).toBe("full");
diff --git a/test/session-commands.test.ts b/test/session-commands.test.ts
index 7dce67e..6ceaacc 100644
--- a/test/session-commands.test.ts
+++ b/test/session-commands.test.ts
@@ -1,3 +1,6 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { describe, expect, it, vi } from "vitest";
 import { registerSessionCommands } from "../packages/core/src/session-commands.js";
@@ -53,4 +56,57 @@ describe("DSCode session commands", () => {
       ),
     });
   });
+
+  it("registers edit-last separately from the new-session alias", () => {
+    const commands = new Map<string, { handler: (args: string, ctx: any) => Promise<void> }>();
+    const pi = {
+      registerCommand(name: string, definition: { handler: (args: string, ctx: any) => Promise<void> }) {
+        commands.set(name, definition);
+      },
+    } as unknown as ExtensionAPI;
+    registerSessionCommands(pi);
+
+    expect(commands.has("clear")).toBe(true);
+    expect(commands.get("edit-last")).toBeDefined();
+  });
+
+  it("rewrites the same session path and switches back to it", async () => {
+    const commands = new Map<string, { handler: (args: string, ctx: any) => Promise<void> }>();
+    const pi = {
+      registerCommand(name: string, definition: { handler: (args: string, ctx: any) => Promise<void> }) {
+        commands.set(name, definition);
+      },
+    } as unknown as ExtensionAPI;
+    registerSessionCommands(pi);
+
+    const entries = [
+      { type: "message", id: "user-1", parentId: null, timestamp: "2026-01-01T00:00:00.000Z", message: { role: "user", content: [{ type: "text", text: "old" }] } },
+      { type: "message", id: "assistant-1", parentId: "user-1", timestamp: "2026-01-01T00:00:01.000Z", message: { role: "assistant", content: [{ type: "text", text: "answer" }] } },
+      { type: "message", id: "user-2", parentId: "assistant-1", timestamp: "2026-01-01T00:00:02.000Z", message: { role: "user", content: [{ type: "text", text: "latest" }] } },
+      { type: "message", id: "assistant-2", parentId: "user-2", timestamp: "2026-01-01T00:00:03.000Z", message: { role: "assistant", content: [{ type: "text", text: "latest answer" }] } },
+    ] as const;
+    const switchSession = vi.fn(async () => ({ cancelled: false }));
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dscode-session-test-"));
+    const sessionFile = path.join(tempDir, "session.jsonl");
+    await fs.writeFile(sessionFile, "old\n");
+    const manager = {
+      getBranch: vi.fn((fromId?: string) => fromId === "assistant-1" ? entries.slice(0, 2) : [...entries]),
+      getSessionFile: vi.fn(() => sessionFile),
+      getHeader: vi.fn(() => null),
+    };
+
+    await commands.get("edit-last")!.handler("", {
+      isIdle: () => true,
+      sessionManager: manager,
+      switchSession,
+    });
+
+    const rewritten = await fs.readFile(sessionFile, "utf8");
+    expect(rewritten).toContain('"user-1"');
+    expect(rewritten).toContain('"assistant-1"');
+    expect(rewritten).not.toContain('"user-2"');
+    expect(rewritten).not.toContain('"assistant-2"');
+    expect(switchSession).toHaveBeenCalledWith(sessionFile);
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
 });
diff --git a/test/state.test.ts b/test/state.test.ts
index 2b2b18c..2332268 100644
--- a/test/state.test.ts
+++ b/test/state.test.ts
@@ -89,6 +89,47 @@ describe("DSCode state index", () => {
       const restored = await store.unarchive("thread-1");
       expect(restored).toMatchObject({ archived: false, pinned: true, sessionPath: runtimePath });
       await expect(fs.stat(runtimePath)).resolves.toBeDefined();
+
+      await expect(store.delete("thread-1")).resolves.toBe(true);
+      await expect(fs.stat(runtimePath)).rejects.toMatchObject({ code: "ENOENT" });
+      await expect(fs.stat(storagePath)).rejects.toMatchObject({ code: "ENOENT" });
+      expect(store.get("thread-1")).toBeUndefined();
+    } finally {
+      store.close();
+    }
+  });
+
+  it("deletes archived transcripts and their index record", async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "dscode-state-delete-test-"));
+    temporaryDirectories.push(root);
+    const home = path.join(root, "home");
+    const sessions = path.join(home, "sessions");
+    const archived = path.join(home, "archived_sessions");
+    process.env.DSCODE_HOME = home;
+    process.env.DSCODE_SESSIONS_DIR = sessions;
+    process.env.DSCODE_ARCHIVED_SESSIONS_DIR = archived;
+    process.env.DSCODE_SQLITE_HOME = home;
+    await fs.mkdir(sessions, { recursive: true });
+    await fs.writeFile(
+      path.join(sessions, "thread-archived.jsonl"),
+      [
+        JSON.stringify({ type: "session", id: "thread-archived", cwd: root }),
+        JSON.stringify({ type: "message", message: { role: "user", content: "Remove this" } }),
+        "",
+      ].join("\n"),
+    );
+    await initializeDSCodeHome();
+
+    const store = new DSCodeStateStore(path.join(home, "state.sqlite"));
+    try {
+      await store.refresh();
+      const archivedThread = await store.archive("thread-archived");
+      expect(archivedThread?.archived).toBe(true);
+      const archivedPath = archivedThread!.storagePath;
+      await expect(fs.stat(archivedPath)).resolves.toBeDefined();
+      await expect(store.delete("thread-archived")).resolves.toBe(true);
+      await expect(fs.stat(archivedPath)).rejects.toMatchObject({ code: "ENOENT" });
+      expect(store.list({ includeArchived: true })).toEqual([]);
     } finally {
       store.close();
     }
diff --git a/test/status.test.ts b/test/status.test.ts
index b889322..8c5d6aa 100644
--- a/test/status.test.ts
+++ b/test/status.test.ts
@@ -1,6 +1,7 @@
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import type { Usage } from "@earendil-works/pi-ai";
 import { describe, expect, it } from "vitest";
+import { createRoutePhaseState, createRouteState } from "../packages/core/src/route-profile.js";
 import { formatStatusReport, summarizeSessionUsage } from "../packages/core/src/status.js";
 
 function usage(input: number, output: number, cacheRead = 0, cacheWrite = 0): Usage {
@@ -42,6 +43,7 @@ describe("/status", () => {
   });
 
   it("explains the stats that are hidden from the default footer", () => {
+    const route = createRouteState("repair-react", "auto", "repair/debug keywords", 0.75);
     const report = formatStatusReport({
       provider: "deepseek",
       model: "deepseek-v4-flash",
@@ -52,6 +54,8 @@ describe("/status", () => {
       network: false,
       cwd: "/work/dscode",
       branch: "main",
+      route,
+      routePhase: createRoutePhaseState(route, 1),
       context: { tokens: 59_000, contextWindow: 1_000_000, percent: 5.9 },
       entries,
     });
@@ -59,5 +63,6 @@ describe("/status", () => {
     expect(report).toContain("59k / 1.0M");
     expect(report).toContain("3.2k uncached input");
     expect(report).toContain("network blocked");
+    expect(report).toContain("route      repair react · auto · 75% · repair/debug keywords · thinking high · working · turn 1");
   });
 });