diff --git a/src/components/chat/session-sidebar/SessionList.svelte b/src/components/chat/session-sidebar/SessionList.svelte
new file mode 100644
index 00000000..3161231f
--- /dev/null
+++ b/src/components/chat/session-sidebar/SessionList.svelte
@@ -0,0 +1,226 @@
+<script lang="ts">
+import { getSessionRegistry } from "../../../stores/chatStore.svelte";
+import { getData } from "../../../stores/dataStore.svelte";
+import { getPlugin } from "../../../stores/state.svelte";
+import { getSessionSidebarStore } from "../../../stores/session-sidebar/sessionSidebarStore.svelte";
+import { filterRows, partition, sortRows } from "../../../stores/session-sidebar/logic";
+import { deriveSessionStatus, type SessionStatus } from "../../../stores/session-sidebar/status";
+import { icon } from "../../../utils/utils";
+import { confirmDelete } from "../../modal/ConfirmModal";
+import { promptText } from "../../modal/PromptModal";
+import type { ThreadPathStore } from "../../../views/chat/threadPathStore.svelte";
+import SessionSidebarItem from "./SessionSidebarItem.svelte";
+
+interface Props {
+	threadPathStore: ThreadPathStore;
+	onOpenSession?: () => void;
+}
+const { threadPathStore, onOpenSession }: Props = $props();
+const threadPath = $derived(threadPathStore.current);
+
+const plugin = getPlugin();
+const store = getSessionSidebarStore();
+const registry = getSessionRegistry();
+const data = getData();
+
+let query = $state("");
+let showArchived = $state(false);
+let visibleCount = $state(50);
+
+const filtered = $derived(filterRows(sortRows(store.rows, data.sessionManagerSort), query));
+const sections = $derived(partition(filtered));
+const listRows = $derived(showArchived ? sections.archived : sections.active);
+const visibleRows = $derived(listRows.slice(0, visibleCount));
+const remaining = $derived(Math.max(0, listRows.length - visibleCount));
+
+/** Status for a row. Only a loaded session can be running, so an unloaded thread
+ * honestly reports idle: the sidebar must never guess an outcome it cannot see. */
+function statusFor(id: string): SessionStatus {
+	const session = registry?.sessionFor(id);
+	if (!session) return "idle";
+	return deriveSessionStatus(session.isRunning, session.lastAssistantState);
+}
+
+async function newChat() {
+	await plugin.agentManager.createNewChat();
+}
+
+async function open(id: string) {
+	await plugin.agentManager.openChatByThreadId(id);
+	onOpenSession?.();
+}
+
+async function del(id: string, title: string) {
+	if (await confirmDelete(plugin.app, title)) await plugin.agentManager.deleteThread(id);
+}
+
+async function rename(id: string, title: string) {
+	const next = await promptText(plugin.app, "Rename chat", title, "Rename");
+	if (next && next !== title) await plugin.agentManager.renameThread(id, next);
+}
+
+function togglePin(id: string, pinned: boolean) {
+	plugin.agentManager.setThreadPinned(id, !pinned);
+	void store.refresh();
+}
+
+function toggleArchive(id: string, archived: boolean) {
+	const ok = plugin.agentManager.setThreadArchived(id, !archived);
+	if (ok) void store.refresh();
+}
+</script>
+
+<div class="s2b-session-header">
+	<button class="s2b-session-new" onclick={newChat} type="button">
+		<span use:icon={"plus"}></span>
+		New chat
+	</button>
+	<button
+		class="s2b-session-archive-toggle"
+		aria-label={showArchived ? "Show sessions" : "Show archived"}
+		class:s2b-session-archive-toggle-active={showArchived}
+		onclick={() => (showArchived = !showArchived)}
+		type="button"
+	>
+		<span use:icon={"archive"}></span>
+	</button>
+</div>
+
+<div class="s2b-session-controls">
+	<input
+		class="s2b-session-search"
+		type="search"
+		placeholder={showArchived ? "Search archived sessions" : "Search sessions"}
+		aria-label={showArchived ? "Search archived sessions" : "Search sessions"}
+		bind:value={query}
+		autocomplete="off"
+	/>
+	<select
+		class="s2b-session-sort dropdown"
+		aria-label="Sort sessions"
+		bind:value={data.sessionManagerSort}
+	>
+		<option value="last-updated">Last updated</option>
+		<option value="created">Created</option>
+	</select>
+</div>
+
+{#if !showArchived && sections.pinned.length}
+	<div class="s2b-session-section s2b-session-section-pinned">
+		<div class="s2b-session-section-label">Pinned</div>
+		{#each sections.pinned as row (row.threadId)}
+			<SessionSidebarItem
+				{row}
+				active={row.threadId === threadPath}
+				status={statusFor(row.threadId)}
+				archivedView={false}
+				onOpen={() => open(row.threadId)}
+				onRename={() => rename(row.threadId, row.title)}
+				onDelete={() => del(row.threadId, row.title)}
+				onTogglePin={() => togglePin(row.threadId, row.pinned)}
+				onToggleArchive={() => toggleArchive(row.threadId, row.archived)}
+			/>
+		{/each}
+	</div>
+{/if}
+
+<div class="s2b-session-section s2b-session-section-list">
+	<div class="s2b-session-section-label">{showArchived ? "Archived" : "Sessions"}</div>
+	{#if visibleRows.length === 0}
+		<div class="s2b-session-empty">{query ? "No matching sessions" : "No conversations"}</div>
+	{/if}
+	{#each visibleRows as row (row.threadId)}
+		<SessionSidebarItem
+			{row}
+			active={row.threadId === threadPath}
+			status={statusFor(row.threadId)}
+			archivedView={showArchived}
+			onOpen={() => open(row.threadId)}
+			onRename={() => rename(row.threadId, row.title)}
+			onDelete={() => del(row.threadId, row.title)}
+			onTogglePin={() => togglePin(row.threadId, row.pinned)}
+			onToggleArchive={() => toggleArchive(row.threadId, row.archived)}
+		/>
+	{/each}
+	{#if remaining > 0}
+		<button class="s2b-session-load-more" onclick={() => (visibleCount += 50)} type="button">
+			Load more ({remaining} remaining)
+		</button>
+	{/if}
+</div>
+
+<style>
+	.s2b-session-header {
+		display: flex;
+		align-items: center;
+		gap: var(--size-2-2);
+		padding: var(--size-4-2);
+		flex: 0 0 auto;
+	}
+
+	.s2b-session-new {
+		display: flex;
+		align-items: center;
+		gap: var(--size-2-2);
+		flex: 1 1 auto;
+		justify-content: center;
+	}
+
+	.s2b-session-archive-toggle {
+		flex: 0 0 auto;
+	}
+
+	.s2b-session-archive-toggle-active {
+		color: var(--text-accent);
+	}
+
+	.s2b-session-controls {
+		display: flex;
+		gap: var(--size-2-2);
+		padding: 0 var(--size-4-2) var(--size-4-2);
+		flex: 0 0 auto;
+	}
+
+	.s2b-session-search {
+		flex: 1 1 auto;
+		min-width: 0;
+	}
+
+	.s2b-session-sort {
+		flex: 0 0 auto;
+	}
+
+	.s2b-session-section {
+		display: flex;
+		flex-direction: column;
+		overflow: hidden;
+	}
+
+	.s2b-session-section-pinned {
+		flex: 0 1 auto;
+		max-height: 50%;
+		overflow-y: auto;
+	}
+
+	.s2b-session-section-list {
+		flex: 1 1 auto;
+		overflow-y: auto;
+	}
+
+	.s2b-session-section-label {
+		padding: var(--size-2-1) var(--size-4-2);
+		color: var(--text-faint);
+		font-size: var(--font-ui-smaller);
+		text-transform: uppercase;
+	}
+
+	.s2b-session-empty {
+		padding: var(--size-4-2);
+		color: var(--text-faint);
+		font-size: var(--font-ui-small);
+	}
+
+	.s2b-session-load-more {
+		margin: var(--size-2-2) var(--size-4-2);
+	}
+</style>
diff --git a/src/components/chat/session-sidebar/SessionSheetModal.ts b/src/components/chat/session-sidebar/SessionSheetModal.ts
new file mode 100644
index 00000000..2e00a543
--- /dev/null
+++ b/src/components/chat/session-sidebar/SessionSheetModal.ts
@@ -0,0 +1,35 @@
+import type { App } from "obsidian";
+import type { ThreadPathStore } from "../../../views/chat/threadPathStore.svelte";
+import { SvelteModal } from "../../modal/SvelteModal";
+import SessionList from "./SessionList.svelte";
+
+/**
+ * Full-height modal hosting the shared session list for narrow/mobile widths,
+ * where the docked `SessionSidebar` has no room. Opening a chat from the list
+ * closes the modal (`onOpenSession`).
+ */
+export class SessionSheetModal extends SvelteModal {
+	constructor(
+		app: App,
+		private threadPathStore: ThreadPathStore,
+	) {
+		super(app);
+	}
+
+	onOpen() {
+		this.setTitle("Sessions");
+		this.modalEl.addClass("s2b-session-sheet");
+
+		this.mountComponent(
+			SessionList,
+			{ threadPathStore: this.threadPathStore, onOpenSession: () => this.close() },
+			{
+				fullScreenOnPhone: true,
+				width: "min(420px, 94vw)",
+				maxWidth: "94vw",
+				height: "min(840px, 92vh)",
+				contentOverflow: "hidden",
+			},
+		);
+	}
+}
diff --git a/src/components/chat/session-sidebar/SessionSidebar.svelte b/src/components/chat/session-sidebar/SessionSidebar.svelte
index 0b2eb6d7..5b5f4f57 100644
--- a/src/components/chat/session-sidebar/SessionSidebar.svelte
+++ b/src/components/chat/session-sidebar/SessionSidebar.svelte
@@ -1,145 +1,15 @@
 <script lang="ts">
-import { getSessionRegistry } from "../../../stores/chatStore.svelte";
-import { getData } from "../../../stores/dataStore.svelte";
-import { getPlugin } from "../../../stores/state.svelte";
-import { getSessionSidebarStore } from "../../../stores/session-sidebar/sessionSidebarStore.svelte";
-import { filterRows, partition, sortRows } from "../../../stores/session-sidebar/logic";
-import { icon } from "../../../utils/utils";
-import { confirmDelete } from "../../modal/ConfirmModal";
-import { promptText } from "../../modal/PromptModal";
-import SessionSidebarItem from "./SessionSidebarItem.svelte";
+import type { ThreadPathStore } from "../../../views/chat/threadPathStore.svelte";
+import SessionList from "./SessionList.svelte";
 
 interface Props {
-	threadPath: string | null;
-}
-const { threadPath }: Props = $props();
-
-const plugin = getPlugin();
-const store = getSessionSidebarStore();
-const registry = getSessionRegistry();
-const data = getData();
-
-let query = $state("");
-let showArchived = $state(false);
-let visibleCount = $state(50);
-
-const filtered = $derived(filterRows(sortRows(store.rows, data.sessionManagerSort), query));
-const sections = $derived(partition(filtered));
-const listRows = $derived(showArchived ? sections.archived : sections.active);
-const visibleRows = $derived(listRows.slice(0, visibleCount));
-const remaining = $derived(Math.max(0, listRows.length - visibleCount));
-
-function isRunning(id: string): boolean {
-	return !!registry?.sessionFor(id)?.isRunning;
-}
-
-async function newChat() {
-	await plugin.agentManager.createNewChat();
-}
-
-async function open(id: string) {
-	await plugin.agentManager.openChatByThreadId(id);
-}
-
-async function del(id: string, title: string) {
-	if (await confirmDelete(plugin.app, title)) await plugin.agentManager.deleteThread(id);
-}
-
-async function rename(id: string, title: string) {
-	const next = await promptText(plugin.app, "Rename chat", title, "Rename");
-	if (next && next !== title) await plugin.agentManager.renameThread(id, next);
-}
-
-function togglePin(id: string, pinned: boolean) {
-	plugin.agentManager.setThreadPinned(id, !pinned);
-	void store.refresh();
-}
-
-function toggleArchive(id: string, archived: boolean) {
-	const ok = plugin.agentManager.setThreadArchived(id, !archived);
-	if (ok) void store.refresh();
+	threadPathStore: ThreadPathStore;
 }
+const { threadPathStore }: Props = $props();
 </script>
 
 <div class="s2b-session-sidebar">
-	<div class="s2b-session-header">
-		<button class="s2b-session-new" onclick={newChat} type="button">
-			<span use:icon={"plus"}></span>
-			New chat
-		</button>
-		<button
-			class="s2b-session-archive-toggle"
-			aria-label={showArchived ? "Show sessions" : "Show archived"}
-			class:s2b-session-archive-toggle-active={showArchived}
-			onclick={() => (showArchived = !showArchived)}
-			type="button"
-		>
-			<span use:icon={"archive"}></span>
-		</button>
-	</div>
-
-	<div class="s2b-session-controls">
-		<input
-			class="s2b-session-search"
-			type="search"
-			placeholder={showArchived ? "Search archived sessions" : "Search sessions"}
-			aria-label={showArchived ? "Search archived sessions" : "Search sessions"}
-			bind:value={query}
-			autocomplete="off"
-		/>
-		<select
-			class="s2b-session-sort dropdown"
-			aria-label="Sort sessions"
-			bind:value={data.sessionManagerSort}
-		>
-			<option value="last-updated">Last updated</option>
-			<option value="created">Created</option>
-		</select>
-	</div>
-
-	{#if !showArchived && sections.pinned.length}
-		<div class="s2b-session-section s2b-session-section-pinned">
-			<div class="s2b-session-section-label">Pinned</div>
-			{#each sections.pinned as row (row.threadId)}
-				<SessionSidebarItem
-					{row}
-					active={row.threadId === threadPath}
-					running={isRunning(row.threadId)}
-					archivedView={false}
-					onOpen={() => open(row.threadId)}
-					onRename={() => rename(row.threadId, row.title)}
-					onDelete={() => del(row.threadId, row.title)}
-					onTogglePin={() => togglePin(row.threadId, row.pinned)}
-					onToggleArchive={() => toggleArchive(row.threadId, row.archived)}
-				/>
-			{/each}
-		</div>
-	{/if}
-
-	<div class="s2b-session-section s2b-session-section-list">
-		<div class="s2b-session-section-label">{showArchived ? "Archived" : "Sessions"}</div>
-		{#if visibleRows.length === 0}
-			<div class="s2b-session-empty">{query ? "No matching sessions" : "No conversations"}</div>
-		{/if}
-		{#each visibleRows as row (row.threadId)}
-			<SessionSidebarItem
-				{row}
-				active={row.threadId === threadPath}
-				running={isRunning(row.threadId)}
-				archivedView={showArchived}
-				onOpen={() => open(row.threadId)}
-				onRename={() => rename(row.threadId, row.title)}
-				onDelete={() => del(row.threadId, row.title)}
-				onTogglePin={() => togglePin(row.threadId, row.pinned)}
-				onToggleArchive={() => toggleArchive(row.threadId, row.archived)}
-			/>
-		{/each}
-		{#if remaining > 0}
-			<button class="s2b-session-load-more" onclick={() => (visibleCount += 50)} type="button">
-				Load more ({remaining} remaining)
-			</button>
-		{/if}
-	</div>
+	<SessionList {threadPathStore} />
 </div>
 
 <style>
@@ -151,78 +21,4 @@ function toggleArchive(id: string, archived: boolean) {
 		overflow: hidden;
 		border-right: 1px solid var(--background-modifier-border);
 	}
-
-	.s2b-session-header {
-		display: flex;
-		align-items: center;
-		gap: var(--size-2-2);
-		padding: var(--size-4-2);
-		flex: 0 0 auto;
-	}
-
-	.s2b-session-new {
-		display: flex;
-		align-items: center;
-		gap: var(--size-2-2);
-		flex: 1 1 auto;
-		justify-content: center;
-	}
-
-	.s2b-session-archive-toggle {
-		flex: 0 0 auto;
-	}
-
-	.s2b-session-archive-toggle-active {
-		color: var(--text-accent);
-	}
-
-	.s2b-session-controls {
-		display: flex;
-		gap: var(--size-2-2);
-		padding: 0 var(--size-4-2) var(--size-4-2);
-		flex: 0 0 auto;
-	}
-
-	.s2b-session-search {
-		flex: 1 1 auto;
-		min-width: 0;
-	}
-
-	.s2b-session-sort {
-		flex: 0 0 auto;
-	}
-
-	.s2b-session-section {
-		display: flex;
-		flex-direction: column;
-		overflow: hidden;
-	}
-
-	.s2b-session-section-pinned {
-		flex: 0 1 auto;
-		max-height: 50%;
-		overflow-y: auto;
-	}
-
-	.s2b-session-section-list {
-		flex: 1 1 auto;
-		overflow-y: auto;
-	}
-
-	.s2b-session-section-label {
-		padding: var(--size-2-1) var(--size-4-2);
-		color: var(--text-faint);
-		font-size: var(--font-ui-smaller);
-		text-transform: uppercase;
-	}
-
-	.s2b-session-empty {
-		padding: var(--size-4-2);
-		color: var(--text-faint);
-		font-size: var(--font-ui-small);
-	}
-
-	.s2b-session-load-more {
-		margin: var(--size-2-2) var(--size-4-2);
-	}
 </style>
diff --git a/src/components/chat/session-sidebar/SessionSidebarItem.svelte b/src/components/chat/session-sidebar/SessionSidebarItem.svelte
index c7ee310e..2f6b2d7b 100644
--- a/src/components/chat/session-sidebar/SessionSidebarItem.svelte
+++ b/src/components/chat/session-sidebar/SessionSidebarItem.svelte
@@ -1,11 +1,13 @@
 <script lang="ts">
+import { Menu } from "obsidian";
 import { icon } from "../../../utils/utils";
 import type { SessionRow } from "../../../stores/session-sidebar/logic";
+import { SESSION_STATUS_DISPLAY, type SessionStatus } from "../../../stores/session-sidebar/status";
 
 interface Props {
 	row: SessionRow;
 	active: boolean;
-	running: boolean;
+	status: SessionStatus;
 	archivedView: boolean;
 	onOpen: () => void;
 	onRename: () => void;
@@ -13,16 +15,64 @@ interface Props {
 	onTogglePin: () => void;
 	onToggleArchive: () => void;
 }
-const { row, active, running, archivedView, onOpen, onRename, onDelete, onTogglePin, onToggleArchive }: Props =
+const { row, active, status, archivedView, onOpen, onRename, onDelete, onTogglePin, onToggleArchive }: Props =
 	$props();
 
+/** running stays the single flag the row actions gate on; it is derived from the
+ * one status value rather than passed separately, so the indicator and the
+ * archive-disable can never disagree. */
+const running = $derived(status === "running");
+const statusDisplay = $derived(SESSION_STATUS_DISPLAY[status]);
+
 const dateStr = $derived(new Date(row.updatedAt).toLocaleDateString());
+
+/**
+ * Touch fallback for the hover-only action buttons (see the `@media (hover:
+ * none)` split below). Mirrors the same row actions in an Obsidian Menu.
+ */
+function openOverflowMenu(event: MouseEvent) {
+	event.stopPropagation();
+	const menu = new Menu();
+
+	menu.addItem((item) => item.setTitle("Open").setIcon("panel-right-open").onClick(onOpen));
+
+	if (archivedView) {
+		menu.addItem((item) => item.setTitle("Restore").setIcon("undo-2").onClick(onToggleArchive));
+	} else {
+		menu.addItem((item) =>
+			item
+				.setTitle(row.pinned ? "Unpin" : "Pin")
+				.setIcon(row.pinned ? "pin-off" : "pin")
+				.onClick(onTogglePin),
+		);
+		menu.addItem((item) => {
+			item.setTitle("Archive").setIcon("archive").onClick(onToggleArchive);
+			if (running) item.setDisabled(true);
+		});
+		menu.addItem((item) => item.setTitle("Rename").setIcon("pencil").onClick(onRename));
+	}
+
+	menu.addItem((item) => item.setTitle("Delete").setIcon("trash-2").setWarning(true).onClick(onDelete));
+
+	menu.showAtMouseEvent(event);
+}
 </script>
 
 <div class="s2b-session-item" class:s2b-session-item-active={active} class:s2b-session-item-running={running}>
 	<button class="s2b-session-item-content" onclick={onOpen} type="button">
-		{#if running}
-			<span class="s2b-session-item-spinner" use:icon={"loader-circle"}></span>
+		{#if status !== "idle"}
+			<span
+				class="s2b-session-item-status"
+				class:s2b-session-item-status-progress={statusDisplay.tone === "progress"}
+				class:s2b-session-item-status-good={statusDisplay.tone === "good"}
+				class:s2b-session-item-status-bad={statusDisplay.tone === "bad"}
+				class:s2b-session-item-status-neutral={statusDisplay.tone === "neutral"}
+				class:s2b-session-item-status-spinning={status === "running"}
+				title={statusDisplay.label}
+			>
+				<span class="s2b-session-item-status-icon" use:icon={statusDisplay.icon}></span>
+				<span class="s2b-session-item-status-label">{statusDisplay.label}</span>
+			</span>
 		{/if}
 		<span class="s2b-session-item-title">{row.title}</span>
 		<span class="s2b-session-item-date">{dateStr}</span>
@@ -58,6 +108,14 @@ const dateStr = $derived(new Date(row.updatedAt).toLocaleDateString());
 			<span use:icon={"trash-2"}></span>
 		</button>
 	</div>
+	<button
+		class="s2b-session-overflow"
+		aria-label="Session actions"
+		onclick={openOverflowMenu}
+		type="button"
+	>
+		<span use:icon={"ellipsis"}></span>
+	</button>
 </div>
 
 <style>
@@ -105,14 +163,50 @@ const dateStr = $derived(new Date(row.updatedAt).toLocaleDateString());
 		font-size: var(--font-ui-smaller);
 	}
 
-	.s2b-session-item-spinner {
+	.s2b-session-item-status {
 		display: inline-flex;
 		flex: 0 0 auto;
 		width: 1em;
 		height: 1em;
+	}
+
+	.s2b-session-item-status-icon {
+		display: inline-flex;
+		width: 1em;
+		height: 1em;
+	}
+
+	.s2b-session-item-status-progress {
+		color: var(--text-accent);
+	}
+
+	.s2b-session-item-status-good {
+		color: var(--color-green);
+	}
+
+	.s2b-session-item-status-bad {
+		color: var(--color-red);
+	}
+
+	.s2b-session-item-status-neutral {
+		color: var(--text-faint);
+	}
+
+	.s2b-session-item-status-spinning .s2b-session-item-status-icon {
 		animation: s2b-session-item-spin 1.2s linear infinite;
 	}
 
+	/* Present in the DOM for assistive tech, invisible on screen: the row is too
+	   narrow for a word, but colour must never be the only signal. */
+	.s2b-session-item-status-label {
+		position: absolute;
+		width: 1px;
+		height: 1px;
+		overflow: hidden;
+		clip-path: inset(50%);
+		white-space: nowrap;
+	}
+
 	@keyframes s2b-session-item-spin {
 		from {
 			transform: rotate(0deg);
@@ -128,9 +222,45 @@ const dateStr = $derived(new Date(row.updatedAt).toLocaleDateString());
 		gap: var(--size-2-1);
 	}
 
-	.s2b-session-item:hover .s2b-session-item-actions,
-	.s2b-session-item:focus-within .s2b-session-item-actions {
-		display: flex;
+	@media (hover: hover) {
+		.s2b-session-item:hover .s2b-session-item-actions,
+		.s2b-session-item:focus-within .s2b-session-item-actions {
+			display: flex;
+		}
+	}
+
+	@media (hover: none) {
+		.s2b-session-item-actions {
+			display: none !important;
+		}
+	}
+
+	.s2b-session-overflow {
+		display: none;
+		flex: 0 0 auto;
+		align-items: center;
+		justify-content: center;
+		width: var(--size-4-6);
+		height: var(--size-4-6);
+		padding: 0;
+		background: transparent;
+		border: none;
+		box-shadow: none;
+		border-radius: var(--radius-s);
+		color: var(--text-muted);
+		cursor: pointer;
+	}
+
+	@media (hover: none) {
+		.s2b-session-overflow {
+			display: inline-flex;
+		}
+	}
+
+	@media (hover: hover) {
+		.s2b-session-overflow {
+			display: none;
+		}
 	}
 
 	.s2b-session-action {
diff --git a/src/components/chat/session-sidebar/resize.ts b/src/components/chat/session-sidebar/resize.ts
index f79ced08..59dd9b9d 100644
--- a/src/components/chat/session-sidebar/resize.ts
+++ b/src/components/chat/session-sidebar/resize.ts
@@ -2,6 +2,11 @@ export type SidebarSide = "left" | "right";
 export const SIDEBAR_MIN = 180;
 export const CHAT_RESERVED = 325; // 320 chat + 5 resizer
 
+/** How long a run of discrete width changes (held arrow key) is coalesced
+ * before being persisted. Drag gestures never wait on this — they persist on
+ * pointerup. */
+export const COMMIT_DEBOUNCE_MS = 250;
+
 /** Clamp a desired sidebar width to `[SIDEBAR_MIN, containerWidth - CHAT_RESERVED]`,
  * falling back to `SIDEBAR_MIN` when the container is too small to leave room
  * for the chat pane. `_side` is unused today (both sides share the same clamp)
@@ -14,7 +19,10 @@ export function clampSidebarWidth(desired: number, containerWidth: number, _side
 
 interface SessionResizerOptions {
 	getWidth: () => number;
-	setWidth: (w: number) => void;
+	/** On-screen only: update the rendered width. Must NOT persist. */
+	previewWidth: (w: number) => void;
+	/** Persist the settled width. Called at most once per gesture. */
+	commitWidth: (w: number) => void;
 	getContainerWidth: () => number;
 	side: SidebarSide;
 }
@@ -22,39 +30,108 @@ interface SessionResizerOptions {
 /** Svelte action for the sidebar's resize divider: pointer-drag and
  * ArrowLeft/ArrowRight (16px step) both clamp through {@link clampSidebarWidth}.
  * Adds/removes a body class while dragging so other UI (e.g. iframes) can
- * suspend pointer-event handling for the duration. */
+ * suspend pointer-event handling for the duration.
+ *
+ * Persistence is deliberately separated from rendering. A drag previews on every
+ * `pointermove` but writes **once**, on `pointerup`; a held arrow key is
+ * coalesced through a short debounce. Writing settings per pointer move is what
+ * corrupted `data.json` on 2026-09-27 — the store's setter saves on every
+ * assignment, so a single drag produced a burst of whole-file writes.
+ *
+ * The pointer is captured on the divider for the duration of a drag, so a release
+ * that lands outside the strip still ends the gesture rather than leaving it
+ * stuck to the cursor. */
 export function sessionResizer(node: HTMLElement, opts: SessionResizerOptions) {
 	let startX = 0;
 	let startW = 0;
+	let dragging = false;
+	let activePointer: number | null = null;
+	let commitTimer: ReturnType<typeof setTimeout> | null = null;
+	let pending: number | null = null;
+
+	const clearCommitTimer = () => {
+		if (commitTimer !== null) {
+			clearTimeout(commitTimer);
+			commitTimer = null;
+		}
+	};
+
+	/** Write the settled width, if one is outstanding. Idempotent. */
+	const flush = () => {
+		clearCommitTimer();
+		if (pending === null) return;
+		const w = pending;
+		pending = null;
+		opts.commitWidth(w);
+	};
+
+	/** Preview immediately; mark the width as needing a commit. */
+	const apply = (w: number) => {
+		opts.previewWidth(w);
+		pending = w;
+	};
+
+	/** Capture the pointer for the whole gesture, so a release that lands outside
+	 * the 5px strip — or over an iframe/webview — still ends the drag instead of
+	 * leaving it stuck to the cursor. Guarded, because headless and test
+	 * environments need not implement capture; the window listeners below deliver
+	 * the gesture either way. */
+	const capturePointer = (id: number) => {
+		try {
+			node.setPointerCapture(id);
+		} catch {
+			activePointer = null;
+		}
+	};
 
 	const onMove = (e: PointerEvent) => {
+		if (!dragging) return;
 		const dir = opts.side === "left" ? 1 : -1;
-		const next = clampSidebarWidth(startW + (e.clientX - startX) * dir, opts.getContainerWidth(), opts.side);
-		opts.setWidth(next);
+		// Preview only. The commit happens on pointerup, so a long or slow drag
+		// cannot turn into a stream of settings writes.
+		apply(clampSidebarWidth(startW + (e.clientX - startX) * dir, opts.getContainerWidth(), opts.side));
 	};
 	const onUp = () => {
+		if (!dragging) return;
+		dragging = false;
 		document.body.classList.remove("s2b-resizing-session-sidebar");
 		window.removeEventListener("pointermove", onMove);
 		window.removeEventListener("pointerup", onUp);
+		window.removeEventListener("pointercancel", onUp);
+		if (activePointer !== null) {
+			try {
+				if (node.hasPointerCapture(activePointer)) node.releasePointerCapture(activePointer);
+			} catch {
+				// Capture was never established; there is nothing to release.
+			}
+			activePointer = null;
+		}
+		flush();
 	};
 	const onDown = (e: PointerEvent) => {
+		dragging = true;
 		startX = e.clientX;
 		startW = opts.getWidth();
+		activePointer = e.pointerId;
+		capturePointer(e.pointerId);
 		document.body.classList.add("s2b-resizing-session-sidebar");
 		window.addEventListener("pointermove", onMove);
 		window.addEventListener("pointerup", onUp);
+		window.addEventListener("pointercancel", onUp);
 		e.preventDefault();
 	};
 	const onKey = (e: KeyboardEvent) => {
 		const step = 16;
 		const dir = opts.side === "left" ? 1 : -1;
 		if (e.key === "ArrowLeft") {
-			opts.setWidth(clampSidebarWidth(opts.getWidth() - step * dir, opts.getContainerWidth(), opts.side));
+			apply(clampSidebarWidth(opts.getWidth() - step * dir, opts.getContainerWidth(), opts.side));
 		} else if (e.key === "ArrowRight") {
-			opts.setWidth(clampSidebarWidth(opts.getWidth() + step * dir, opts.getContainerWidth(), opts.side));
+			apply(clampSidebarWidth(opts.getWidth() + step * dir, opts.getContainerWidth(), opts.side));
 		} else {
 			return;
 		}
+		// Discrete presses with no "release" signal, so coalesce a held key.
+		if (commitTimer === null) commitTimer = setTimeout(flush, COMMIT_DEBOUNCE_MS);
 		e.preventDefault();
 	};
 
@@ -65,6 +142,8 @@ export function sessionResizer(node: HTMLElement, opts: SessionResizerOptions) {
 		destroy() {
 			node.removeEventListener("pointerdown", onDown);
 			node.removeEventListener("keydown", onKey);
+			// Do not lose a width the user already chose.
+			flush();
 			onUp();
 		},
 	};
diff --git a/src/stores/chatStore.svelte.ts b/src/stores/chatStore.svelte.ts
index 3dcda9dc..c03790c8 100644
--- a/src/stores/chatStore.svelte.ts
+++ b/src/stores/chatStore.svelte.ts
@@ -14,6 +14,7 @@ import { formatSelectionContext, type SelectionRef } from "../hooks/useSelection
 import { type UUIDv7, genUUIDv7 } from "../utils/uuid7Validator";
 import { DEFAULT_AGENT_ID } from "./agentDefaults";
 import { getData } from "./dataStore.svelte";
+import { emitRunCue, outcomeForAssistantState, primeAudio } from "./runCue";
 import { getPlugin } from "./state.svelte";
 import { Logger } from "../utils/logging";
 import { shouldSummarizeForEstimatedTokens } from "../agent/summarization";
@@ -132,6 +133,14 @@ export class ChatSession {
 		return this.running;
 	}
 
+	/** State of the last message pair's assistant message, or undefined while the
+	 * session holds no messages. Read by the session sidebar to show a per-row
+	 * outcome for sessions that are already loaded, without opening the thread.
+	 * Reactive: messages is $state, so a row updates as a run settles. */
+	get lastAssistantState(): AssistantState | undefined {
+		return this.messages[this.messages.length - 1]?.assistantMessage.state;
+	}
+
 	touch(): void {
 		this.lastTouchedAt = Date.now();
 	}
@@ -613,6 +622,9 @@ export class ChatSession {
 		}
 
 		this.abortController = new AbortController();
+		// A run is always started by a user gesture, which is the only moment
+		// Chromium lets us open an AudioContext that can actually be heard later.
+		primeAudio();
 		this.running = true;
 		const signal = this.abortController.signal;
 		this.touch();
@@ -759,6 +771,13 @@ export class ChatSession {
 			this.summarizingHistory = false;
 			this.messageState = MessageState.idle;
 			this.touch();
+			// One cue per settled run. The catch above has already normalised the
+			// outcome, so this reads a real terminal state, and it fires from the
+			// session rather than a pane, so it happens once however many are open.
+			emitRunCue(outcomeForAssistantState(settledPair?.assistantMessage.state), () => ({
+				sound: getData().runSoundEnabled,
+				notification: getData().runNotificationEnabled,
+			}));
 		}
 	}
 
diff --git a/src/stores/dataStore.svelte.ts b/src/stores/dataStore.svelte.ts
index 5d43eba2..74c2c888 100644
--- a/src/stores/dataStore.svelte.ts
+++ b/src/stores/dataStore.svelte.ts
@@ -235,6 +235,8 @@ export const DEFAULT_SETTINGS: PluginData = {
 	sessionSidebarSide: "right",
 	sessionManagerSort: "last-updated",
 	sessionSidebarWidth: 240,
+	runSoundEnabled: true,
+	runNotificationEnabled: true,
 	sessionFlags: {},
 	onboardingComplete: false,
 	onboardingSplashSeen: false,
@@ -1602,6 +1604,22 @@ export class PluginDataStore {
 		void this.saveSettings();
 	}
 
+	get runSoundEnabled(): boolean {
+		return this.#data.runSoundEnabled ?? true;
+	}
+	set runSoundEnabled(val: boolean) {
+		this.#data.runSoundEnabled = val;
+		void this.saveSettings();
+	}
+
+	get runNotificationEnabled(): boolean {
+		return this.#data.runNotificationEnabled ?? true;
+	}
+	set runNotificationEnabled(val: boolean) {
+		this.#data.runNotificationEnabled = val;
+		void this.saveSettings();
+	}
+
 	// --- Session Flags (pin/archive) ---
 
 	getSessionFlags(path: string): SessionFlags {
diff --git a/src/stores/runCue.ts b/src/stores/runCue.ts
new file mode 100644
index 00000000..62288abf
--- /dev/null
+++ b/src/stores/runCue.ts
@@ -0,0 +1,130 @@
+import { Notice } from "obsidian";
+import { AssistantState } from "./chatTimeline";
+
+/** The terminal outcome of a chat run. Mirrors the settled assistant state, so
+ * there is one source of truth for "how did this turn end". */
+export type RunOutcome = "success" | "error" | "cancelled";
+
+export interface RunCueSettings {
+	/** Play a short tone when a run settles. */
+	sound: boolean;
+	/** Raise a native notification when a run settles. */
+	notification: boolean;
+}
+
+export interface RunCue {
+	/** false for outcomes that must stay silent. */
+	play: boolean;
+	/** Tone frequency in Hz, or null for no sound. */
+	frequency: number | null;
+	/** Notification body, or null for no notification. */
+	body: string | null;
+}
+
+/** How long the tone is held. A cue, not a jingle. */
+export const CUE_DURATION_MS = 140;
+/** Distinct by ear: a failure must not sound like a completion. */
+export const CUE_DONE_HZ = 880;
+export const CUE_FAIL_HZ = 320;
+
+/**
+ * Decide what a settled run should emit.
+ *
+ * `cancelled` is deliberately silent: the user asked for the stop, so a cue
+ * would be noise rather than information. Pure, so the decision is testable
+ * without an AudioContext or a renderer.
+ */
+export function cueForOutcome(outcome: RunOutcome, settings: RunCueSettings): RunCue {
+	if (outcome === "cancelled") return { play: false, frequency: null, body: null };
+	const failed = outcome === "error";
+	return {
+		play: true,
+		frequency: settings.sound ? (failed ? CUE_FAIL_HZ : CUE_DONE_HZ) : null,
+		body: settings.notification ? (failed ? "Chat run failed" : "Chat run finished") : null,
+	};
+}
+
+/** Map a settled assistant state to an outcome. Anything not terminal returns
+ * null and fires nothing. */
+export function outcomeForAssistantState(state: AssistantState | undefined): RunOutcome | null {
+	switch (state) {
+		case AssistantState.success:
+			return "success";
+		case AssistantState.error:
+			return "error";
+		case AssistantState.cancelled:
+			return "cancelled";
+		default:
+			return null;
+	}
+}
+
+// --- emission: renderer-dependent, best-effort, must never throw ---
+
+let audioCtx: AudioContext | null = null;
+
+/**
+ * Called from a user gesture (send / submit). Chromium gates audio until a
+ * gesture has happened, so this is the only reliable moment to open a context
+ * that can actually be heard later. Best-effort: failure just means no tone.
+ */
+export function primeAudio(): void {
+	try {
+		if (typeof AudioContext === "undefined") return;
+		if (!audioCtx) audioCtx = new AudioContext();
+		if (audioCtx.state === "suspended") void audioCtx.resume();
+	} catch {
+		audioCtx = null;
+	}
+}
+
+function playTone(frequency: number): void {
+	try {
+		if (!audioCtx || audioCtx.state !== "running") return;
+		const osc = audioCtx.createOscillator();
+		const gain = audioCtx.createGain();
+		osc.frequency.value = frequency;
+		gain.gain.value = 0.05; // quiet: a cue, not an alarm
+		osc.connect(gain).connect(audioCtx.destination);
+		const now = audioCtx.currentTime;
+		osc.start(now);
+		osc.stop(now + CUE_DURATION_MS / 1000);
+	} catch {
+		// A blocked or failed cue must never break the run\u2019s bookkeeping.
+	}
+}
+
+function notify(body: string): void {
+	try {
+		if (typeof Notification !== "undefined" && Notification.permission === "granted") {
+			new Notification(body);
+			return;
+		}
+		// Notice is the guaranteed floor, and is not gated by permission.
+		new Notice(body);
+	} catch {
+		// Never throw into a settled run.
+	}
+}
+
+/**
+ * Emit the cue for a settled run. No-op when the outcome is not terminal.
+ *
+ * Settings arrive as a thunk and are read *inside* the guard, because the read
+ * itself can throw: the run's `finally` can execute in a context with no plugin
+ * (headless, or the unit tests for this path). A cue must never be able to break
+ * the bookkeeping of a run that has already settled.
+ */
+export function emitRunCue(outcome: RunOutcome | null, readSettings: () => RunCueSettings): void {
+	if (!outcome) return;
+	let settings: RunCueSettings;
+	try {
+		settings = readSettings();
+	} catch {
+		return;
+	}
+	const cue = cueForOutcome(outcome, settings);
+	if (!cue.play) return;
+	if (cue.frequency !== null) playTone(cue.frequency);
+	if (cue.body) notify(cue.body);
+}
diff --git a/src/stores/session-sidebar/status.ts b/src/stores/session-sidebar/status.ts
new file mode 100644
index 00000000..50f76179
--- /dev/null
+++ b/src/stores/session-sidebar/status.ts
@@ -0,0 +1,56 @@
+import { AssistantState } from "../chatTimeline";
+
+/** At-a-glance state of a chat session in the sidebar.
+ *
+ * `idle` is the honest unknown: the thread is not loaded into a live session,
+ * so the plugin genuinely does not know what happened to its last turn. It is
+ * deliberately not coloured green — a status surface must never guess. */
+export type SessionStatus = "running" | "done" | "failed" | "cancelled" | "interrupted" | "idle";
+
+export interface SessionStatusDisplay {
+	/** Obsidian (lucide) icon name. */
+	icon: string;
+	/** Text label. Always rendered — colour alone is never the only signal. */
+	label: string;
+	/** CSS class suffix; the colour lives in the stylesheet, not here. */
+	tone: "neutral" | "progress" | "good" | "bad";
+}
+
+export const SESSION_STATUS_DISPLAY: Record<SessionStatus, SessionStatusDisplay> = {
+	running: { icon: "loader-circle", label: "Running", tone: "progress" },
+	done: { icon: "circle-check", label: "Done", tone: "good" },
+	failed: { icon: "circle-alert", label: "Failed", tone: "bad" },
+	cancelled: { icon: "circle-slash", label: "Stopped", tone: "neutral" },
+	interrupted: { icon: "circle-dashed", label: "Interrupted", tone: "neutral" },
+	idle: { icon: "circle", label: "Not loaded", tone: "neutral" },
+};
+
+/**
+ * Derive a row's status.
+ *
+ * `isRunning` is the live registry flag (`ChatSession.isRunning`). Otherwise the
+ * answer comes from the *last* message pair's assistant state, which the session
+ * holds reactively in memory.
+ *
+ * `streaming` with nothing running means the app was closed mid-stream: the pair
+ * stays in that state forever, but nothing is actually happening. It is neither
+ * done nor failed, so it reports `interrupted` rather than inventing an outcome.
+ */
+export function deriveSessionStatus(
+	isRunning: boolean,
+	lastAssistantState: AssistantState | undefined,
+): SessionStatus {
+	if (isRunning) return "running";
+	switch (lastAssistantState) {
+		case AssistantState.success:
+			return "done";
+		case AssistantState.error:
+			return "failed";
+		case AssistantState.cancelled:
+			return "cancelled";
+		case AssistantState.streaming:
+			return "interrupted";
+		default:
+			return "idle";
+	}
+}
diff --git a/src/types/plugin.ts b/src/types/plugin.ts
index 872913bf..e05c922d 100644
--- a/src/types/plugin.ts
+++ b/src/types/plugin.ts
@@ -574,6 +574,10 @@ export interface PluginData {
 	sessionManagerSort: "last-updated" | "created";
 	/** Persisted width (px) of the session sidebar. */
 	sessionSidebarWidth: number;
+	/** Play a short tone when a chat run settles (success or failure). */
+	runSoundEnabled: boolean;
+	/** Raise a notification when a chat run settles (success or failure). */
+	runNotificationEnabled: boolean;
 	/** Pin/archive flags per chat session, keyed by thread file path. */
 	sessionFlags: Record<string, SessionFlags>;
 	/** Whether the user has completed (or dismissed) the first-run onboarding flow. */
diff --git a/src/views/chat/Chat.svelte b/src/views/chat/Chat.svelte
index ab0f1650..6ea5af47 100644
--- a/src/views/chat/Chat.svelte
+++ b/src/views/chat/Chat.svelte
@@ -2,6 +2,7 @@
 import { QueryClientProvider } from "@tanstack/svelte-query";
 import Input from "../../components/chat/Input.svelte";
 import MessageContainer from "../../components/chat/MessageContainer.svelte";
+import { SessionSheetModal } from "../../components/chat/session-sidebar/SessionSheetModal";
 import SessionSidebar from "../../components/chat/session-sidebar/SessionSidebar.svelte";
 import { sessionResizer } from "../../components/chat/session-sidebar/resize";
 import { getSessionRegistry } from "../../stores/chatStore.svelte";
@@ -29,6 +30,10 @@ const data = getData();
 // hidden (dropdown fallback for the narrow case is a deferred fast-follow).
 let rootEl = $state<HTMLElement | null>(null);
 let containerWidth = $state(0);
+/** Width being dragged right now. Non-null only during a gesture, so the
+ * on-screen size follows the pointer while the *persisted* value
+ * (`data.sessionSidebarWidth`) is written once, on release. */
+let dragWidth = $state<number | null>(null);
 const wide = $derived(data.enableSessionSidebar && containerWidth >= 600);
 
 function observeWidth(node: HTMLElement) {
@@ -43,7 +48,7 @@ function observeWidth(node: HTMLElement) {
 }
 
 $effect(() => {
-	if (rootEl) rootEl.style.setProperty("--s2b-session-sidebar-width", `${data.sessionSidebarWidth}px`);
+	if (rootEl) rootEl.style.setProperty("--s2b-session-sidebar-width", `${dragWidth ?? data.sessionSidebarWidth}px`);
 });
 
 let messageContainer = $state<ReturnType<typeof MessageContainer> | undefined>();
@@ -329,7 +334,7 @@ function portalComposer(node: HTMLElement) {
     use:observeWidth
   >
     {#if wide}
-      <SessionSidebar {threadPath} />
+      <SessionSidebar {threadPathStore} />
       <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
       <!-- role="separator" is correct per WAI-ARIA for a resizable-widget divider,
            and the widget IS interactive (drag + arrow-key resize) even though
@@ -342,7 +347,9 @@ function portalComposer(node: HTMLElement) {
         tabindex="0"
         use:sessionResizer={{
           getWidth: () => data.sessionSidebarWidth,
-          setWidth: (w) => (data.sessionSidebarWidth = w),
+          // Live width while dragging: component-local, so a drag never writes settings.
+          previewWidth: (w) => (dragWidth = w),
+          commitWidth: (w) => { dragWidth = null; data.sessionSidebarWidth = w; },
           getContainerWidth: () => containerWidth,
           side: data.sessionSidebarSide,
         }}
@@ -358,6 +365,20 @@ function portalComposer(node: HTMLElement) {
       ondrop={handleRootDrop}
       use:portalComposer
     >
+      {#if !wide && data.enableSessionSidebar}
+        <div class="s2b-session-sheet-trigger-bar">
+          <button
+            type="button"
+            class="clickable-icon s2b-session-sheet-trigger"
+            aria-label="Open sessions"
+            onclick={() => new SessionSheetModal(plugin.app, threadPathStore).open()}
+          >
+            <div class="w-icon-xs h-icon-xs" use:icon={"panel-left-open"} style="--icon-size: var(--icon-xs)"></div>
+            <span>Sessions</span>
+          </button>
+        </div>
+      {/if}
+
       {#if registry}
         <MessageContainer bind:this={messageContainer} {registry} {threadPath} />
         <Input
@@ -505,6 +526,32 @@ function portalComposer(node: HTMLElement) {
     --chat-bg: var(--background-primary);
   }
 
+  /* Compact mobile-only entry point to the session list (SessionSheetModal),
+     only mounted when the in-leaf sidebar is hidden (`!wide`) — see the
+     `{#if}` gate in the template, which also keeps this from ever
+     double-upping with `SessionSidebar` as the entry point. A slim flow
+     element at the top of `.chat-root`'s flex column, so it takes up real
+     height and `MessageContainer` (flex-1) scrolls below it rather than
+     under it. */
+  .s2b-session-sheet-trigger-bar {
+    flex: 0 0 auto;
+    display: flex;
+    padding: 4px 8px;
+    border-bottom: 1px solid var(--background-modifier-border);
+    background: var(--chat-bg);
+    position: relative;
+    z-index: 26;
+  }
+
+  .s2b-session-sheet-trigger {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 4px 8px;
+    font-size: var(--font-ui-smaller);
+    color: var(--text-muted);
+  }
+
   /* The composer sizes itself against the chat pane's height (see
      `--s2b-chat-pane-height` in Input.svelte). On desktop it is an in-flow
      child of `.chat-root`, so the pane is a size container and `cqh` measures
diff --git a/src/views/settings/AgentsSettings.svelte b/src/views/settings/AgentsSettings.svelte
index d1bd9d29..0f00c209 100644
--- a/src/views/settings/AgentsSettings.svelte
+++ b/src/views/settings/AgentsSettings.svelte
@@ -273,6 +273,20 @@ function getAgentSkillsSummary(agentId: string): { icons: string[]; overflow: nu
       />
     </SettingItem>
 
+    <SettingItem name="Completion sound" desc="Play a short tone when a chat run finishes or fails">
+      <Toggle
+        checked={pluginData.runSoundEnabled}
+        onchange={(checked) => (pluginData.runSoundEnabled = checked)}
+      />
+    </SettingItem>
+
+    <SettingItem name="Run notifications" desc="Show a notification when a chat run finishes or fails">
+      <Toggle
+        checked={pluginData.runNotificationEnabled}
+        onchange={(checked) => (pluginData.runNotificationEnabled = checked)}
+      />
+    </SettingItem>
+
     <!-- Obsidian mobile has no status bar (addStatusBarItem is a no-op there), so the
          toggle would control nothing. Hide it rather than offering a dead switch. -->
     {#if !isMobileUI()}
diff --git a/test/components/sessionResizePersistence.test.ts b/test/components/sessionResizePersistence.test.ts
new file mode 100644
index 00000000..5a56e05b
--- /dev/null
+++ b/test/components/sessionResizePersistence.test.ts
@@ -0,0 +1,82 @@
+import { describe, expect, it, vi } from "vitest";
+import { sessionResizer, type SidebarSide } from "../../src/components/chat/session-sidebar/resize";
+
+/** Mount the resizer on a detached node with counting spies, so a test can
+ * assert *how many times* a gesture persists — not just where it ends up. */
+function mount(initial = 240, side: SidebarSide = "right") {
+	let width = initial;
+	const previews: number[] = [];
+	const commits: number[] = [];
+	const node = document.createElement("div");
+	const action = sessionResizer(node, {
+		getWidth: () => width,
+		previewWidth: (w) => {
+			width = w;
+			previews.push(w);
+		},
+		commitWidth: (w) => {
+			commits.push(w);
+		},
+		getContainerWidth: () => 1200,
+		side,
+	});
+	document.body.appendChild(node);
+	return { node, action, previews, commits, width: () => width };
+}
+
+const down = (x: number) => window.dispatchEvent(new MouseEvent("pointerdown", { clientX: x }));
+const move = (x: number) => window.dispatchEvent(new MouseEvent("pointermove", { clientX: x }));
+const up = () => window.dispatchEvent(new MouseEvent("pointerup"));
+
+describe("sessionResizer persistence", () => {
+	it("previews every move but persists exactly once for a whole drag", () => {
+		vi.useFakeTimers();
+		const d = mount();
+		d.node.dispatchEvent(new MouseEvent("pointerdown", { clientX: 1000 }));
+		for (let i = 1; i <= 50; i++) move(1000 - i * 3);
+
+		expect(d.previews.length).toBe(50);
+		expect(d.commits.length).toBe(0); // nothing written mid-gesture
+
+		up();
+		vi.useRealTimers();
+		expect(d.commits.length).toBe(1);
+		expect(d.commits[0]).toBe(d.previews[d.previews.length - 1]);
+	});
+
+	it("does not persist mid-drag even when the drag outlasts the debounce", () => {
+		// The regression this guards: a slow drag must not become a write burst.
+		vi.useFakeTimers();
+		const d = mount();
+		d.node.dispatchEvent(new MouseEvent("pointerdown", { clientX: 1000 }));
+		move(990);
+		vi.advanceTimersByTime(5000);
+		expect(d.commits.length).toBe(0);
+		up();
+		vi.useRealTimers();
+		expect(d.commits.length).toBe(1);
+	});
+
+	it("coalesces a held arrow key into a single persist", () => {
+		vi.useFakeTimers();
+		const d = mount();
+		for (let i = 0; i < 5; i++) {
+			d.node.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowLeft" }));
+			vi.advanceTimersByTime(20); // faster than the commit debounce
+		}
+		expect(d.commits.length).toBe(0);
+		vi.advanceTimersByTime(500);
+		vi.useRealTimers();
+		expect(d.commits.length).toBe(1);
+	});
+
+	it("commits the final width, so the size survives a reload", () => {
+		// Guards the opposite failure: silencing the write while losing the value.
+		const d = mount();
+		d.node.dispatchEvent(new MouseEvent("pointerdown", { clientX: 1000 }));
+		move(950);
+		up();
+		expect(d.width()).toBe(290); // 240 + 50
+		expect(d.commits).toEqual([290]);
+	});
+});
diff --git a/test/stores/runCue.test.ts b/test/stores/runCue.test.ts
new file mode 100644
index 00000000..5687309a
--- /dev/null
+++ b/test/stores/runCue.test.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { AssistantState } from "../../src/stores/chatTimeline";
+import { CUE_DONE_HZ, CUE_FAIL_HZ, cueForOutcome, outcomeForAssistantState } from "../../src/stores/runCue";
+
+describe("cueForOutcome", () => {
+	const on = { sound: true, notification: true };
+	const off = { sound: false, notification: false };
+
+	it("stays silent for a run the user cancelled", () => {
+		expect(cueForOutcome("cancelled", on)).toEqual({ play: false, frequency: null, body: null });
+	});
+
+	it("gives failure and completion distinguishable tones", () => {
+		expect(cueForOutcome("error", on).frequency).toBe(CUE_FAIL_HZ);
+		expect(cueForOutcome("success", on).frequency).toBe(CUE_DONE_HZ);
+		expect(CUE_FAIL_HZ).not.toBe(CUE_DONE_HZ);
+	});
+
+	it("keeps sound and notification independently toggleable", () => {
+		expect(cueForOutcome("success", { sound: true, notification: false })).toMatchObject({
+			frequency: CUE_DONE_HZ,
+			body: null,
+		});
+		expect(cueForOutcome("success", { sound: false, notification: true })).toMatchObject({
+			frequency: null,
+			body: "Chat run finished",
+		});
+	});
+
+	it("still settles with both cues off, emitting nothing", () => {
+		const cue = cueForOutcome("success", off);
+		expect(cue.play).toBe(true);
+		expect(cue.frequency).toBeNull();
+		expect(cue.body).toBeNull();
+	});
+});
+
+describe("outcomeForAssistantState", () => {
+	it("maps the three terminal states", () => {
+		expect(outcomeForAssistantState(AssistantState.success)).toBe("success");
+		expect(outcomeForAssistantState(AssistantState.error)).toBe("error");
+		expect(outcomeForAssistantState(AssistantState.cancelled)).toBe("cancelled");
+	});
+
+	it("fires nothing for a state that is not terminal", () => {
+		expect(outcomeForAssistantState(AssistantState.streaming)).toBeNull();
+		expect(outcomeForAssistantState(AssistantState.idle)).toBeNull();
+		expect(outcomeForAssistantState(undefined)).toBeNull();
+	});
+});
diff --git a/test/stores/sessionStatus.test.ts b/test/stores/sessionStatus.test.ts
new file mode 100644
index 00000000..5b78611f
--- /dev/null
+++ b/test/stores/sessionStatus.test.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { AssistantState } from "../../src/stores/chatTimeline";
+import { deriveSessionStatus, SESSION_STATUS_DISPLAY } from "../../src/stores/session-sidebar/status";
+
+describe("deriveSessionStatus", () => {
+	it("reports running whenever the session is live, whatever the last message says", () => {
+		expect(deriveSessionStatus(true, AssistantState.success)).toBe("running");
+		expect(deriveSessionStatus(true, AssistantState.error)).toBe("running");
+		expect(deriveSessionStatus(true, undefined)).toBe("running");
+	});
+
+	it("maps each terminal assistant state", () => {
+		expect(deriveSessionStatus(false, AssistantState.success)).toBe("done");
+		expect(deriveSessionStatus(false, AssistantState.error)).toBe("failed");
+		expect(deriveSessionStatus(false, AssistantState.cancelled)).toBe("cancelled");
+	});
+
+	it("reports an orphaned stream as interrupted, not done and not failed", () => {
+		// App closed mid-stream: the pair stays at streaming with nothing running.
+		// Guessing an outcome here would put a false claim on a status surface.
+		expect(deriveSessionStatus(false, AssistantState.streaming)).toBe("interrupted");
+	});
+
+	it("reports idle when the thread is not loaded - unknown, never assumed done", () => {
+		expect(deriveSessionStatus(false, undefined)).toBe("idle");
+		expect(deriveSessionStatus(false, AssistantState.idle)).toBe("idle");
+	});
+
+	it("gives every status an icon AND a text label, so colour is never the only signal", () => {
+		for (const [status, display] of Object.entries(SESSION_STATUS_DISPLAY)) {
+			expect(display.icon, status).toBeTruthy();
+			expect(display.label, status).toBeTruthy();
+		}
+	});
+});