@@ -2068,9 +2068,10 @@ export class AgentHostStateManager extends Disposable {
 	 *    keyed by the owning session URI;
 	 *  - mirror the chat's denormalized `status`/`activity`/`modifiedAt`
 	 *    onto the session summary so the session list reflects progress;
-	 *  - forward the chat's own `status` to the session `chats` catalog (via a
-	 *    {@link ActionType.SessionChatUpdated}) so per-chat tabs reflect that
-	 *    chat's progress, not just the aggregated session summary; and
+	 *  - forward the chat's own `status`, `activity`, and `modifiedAt` to the
+	 *    session `chats` catalog (via a {@link ActionType.SessionChatUpdated})
+	 *    so per-chat tabs reflect that chat's progress, not just the aggregated
+	 *    session summary; and
 	 *  - keep the session's `chats` catalog entry in sync.
 	 */
 	private _onChatStateChanged(sessionKey: string, chatUri: string, prev: ChatState, next: ChatState): void {
@@ -2120,15 +2121,20 @@ export class AgentHostStateManager extends Disposable {
 		const prevEntry = sessionState.chats.find(c => c.resource === chatUri);
 		const chats = sessionState.chats.map(c => c.resource === chatUri ? nextEntry : c);
 
-		// Forward the chat's own status to the session catalog so full
-		// SessionState subscribers (the per-chat tabs) reflect this chat's
-		// progress — not just the aggregated session summary. Status changes
-		// at most a couple of times per turn, so this won't flood the channel.
-		if (prevEntry?.status !== nextEntry.status) {
+		// Forward chat-local status, activity, and modification time to SessionState
+		// subscribers, not just to the aggregated session summary.
+		const chatStatusChanged = prevEntry?.status !== nextEntry.status;
+		const chatActivityChanged = prevEntry?.activity !== nextEntry.activity;
+		const chatModifiedAtChanged = prevEntry?.modifiedAt !== nextEntry.modifiedAt;
+		if (chatStatusChanged || chatActivityChanged || chatModifiedAtChanged) {
 			this.dispatchServerAction(sessionKey, {
 				type: ActionType.SessionChatUpdated,
 				chat: chatUri,
-				changes: { status: nextEntry.status, activity: nextEntry.activity },
+				changes: {
+					...(chatStatusChanged ? { status: nextEntry.status } : undefined),
+					...(chatActivityChanged ? { activity: nextEntry.activity } : undefined),
+					...(chatModifiedAtChanged ? { modifiedAt: nextEntry.modifiedAt } : undefined),
+				},
 			});
 		}
 
 
@@ -1444,7 +1444,7 @@ suite('AgentHostStateManager', () => {
 				action: {
 					type: ActionType.SessionChatUpdated,
 					chat: peerChat,
-					changes: { status: SessionStatus.Idle | SessionStatus.IsArchived, activity: undefined },
+					changes: { status: SessionStatus.Idle | SessionStatus.IsArchived },
 				},
 			});
 		});
@@ -1633,15 +1633,14 @@ suite('AgentHostStateManager', () => {
 			);
 		});
 
-		test('a running peer chat forwards its own status to the session catalog so its tab can show progress', () => {
+		test('a running peer chat forwards its own progress to the session catalog', () => {
 			manager.createSession(makeSessionSummary());
 			manager.addChat(sessionUri, peerChat, { title: 'Peer' });
 
 			const envelopes: ActionEnvelope[] = [];
 			disposables.add(manager.onDidEmitEnvelope(e => envelopes.push(e)));
 
 			const peerCatalogStatus = () => manager.getSessionState(sessionUri)?.chats.find(c => c.resource === peerChat)?.status ?? SessionStatus.Idle;
-			const chatUpdatesForPeer = () => envelopes.filter(e => e.action.type === ActionType.SessionChatUpdated && (e.action as { chat: string }).chat === peerChat).length;
 
 			const idleCatalog = peerCatalogStatus();
 
@@ -1652,7 +1651,13 @@ suite('AgentHostStateManager', () => {
 				message: { text: 'b', origin: { kind: MessageKind.User } },
 			});
 			const runningCatalog = peerCatalogStatus();
-			const updatesAfterStart = chatUpdatesForPeer();
+			const updatesAfterStart = envelopes.filter(e => e.action.type === ActionType.SessionChatUpdated && e.action.chat === peerChat);
+
+			manager.dispatchServerAction(peerChat, {
+				type: ActionType.ChatActivityChanged,
+				activity: 'Running tests',
+			});
+			const updatesAfterActivity = envelopes.filter(e => e.action.type === ActionType.SessionChatUpdated && e.action.chat === peerChat);
 
 			manager.dispatchServerAction(peerChat, {
 				type: ActionType.ChatTurnComplete,
@@ -1665,13 +1670,28 @@ suite('AgentHostStateManager', () => {
 					idleCatalogInProgress: (idleCatalog & SessionStatus.InProgress) === SessionStatus.InProgress,
 					runningCatalogInProgress: (runningCatalog & SessionStatus.InProgress) === SessionStatus.InProgress,
 					finalCatalogInProgress: (peerCatalogStatus() & SessionStatus.InProgress) === SessionStatus.InProgress,
-					emittedChatUpdateOnStart: updatesAfterStart >= 1,
+					startUpdate: updatesAfterStart.at(-1)?.action,
+					activityUpdate: updatesAfterActivity.at(-1)?.action,
 				},
 				{
 					idleCatalogInProgress: false,
 					runningCatalogInProgress: true,
 					finalCatalogInProgress: false,
-					emittedChatUpdateOnStart: true,
+					startUpdate: {
+						type: ActionType.SessionChatUpdated,
+						chat: peerChat,
+						changes: {
+							status: SessionStatus.InProgress,
+							modifiedAt: '2025-01-01T00:00:00.000Z',
+						},
+					},
+					activityUpdate: {
+						type: ActionType.SessionChatUpdated,
+						chat: peerChat,
+						changes: {
+							activity: 'Running tests',
+						},
+					},
 				},
 			);
 		});
 
@@ -167,7 +167,7 @@ Provider-specific configuration remains opaque to shared Sessions code. Scoped A
 
 ### Operations
 
-Providers implement only operations advertised by their contracts, including request sending, model selection, rename, archive, read state, deletion, chat creation, and optional worktree disk-usage measurement. Shared cleanup UI consumes the optional measurement through the management service and remains independent of provider transport or filesystem details. Capability checks happen before invocation. Once invoked, an operation returns a defined result or rejects; unsupported behavior must not be reported as a success-shaped fallback.
+Providers implement only operations advertised by their contracts, including request sending, model selection, rename, archive, session read state, optional chat-scoped read state, deletion, chat creation, and optional worktree disk-usage measurement. Opening a chat marks that chat read; providers without chat-scoped state fall back to the owning session's read state. Shared cleanup UI consumes the optional measurement through the management service and remains independent of provider transport or filesystem details. Capability checks happen before invocation. Once invoked, an operation returns a defined result or rejects; unsupported behavior must not be reported as a success-shaped fallback.
 
 ### Provider ownership
 
 
@@ -153,7 +153,7 @@ The indexed envelope also carries payload-derived top-level eligibility. Chat-ba
 
 Session listing resolves each registered session independently from its verified current-version payload. A missing, outdated, or malformed payload falls back to the legacy/provider source for that row and schedules reconciliation. A valid chat-backing envelope remains authoritative and never falls back into the top-level session list.
 
-The verified payload's ordered chat identities, titles, and interactivity are projected into the session facade during listing without opening the per-session database. Observing a peer chat's transient details acquires the existing session-state subscription; the subscription reconciles volatile status and activity onto the same stable chat facades and follows the observer lifetime before returning to the existing idle-release policy.
+The verified payload's ordered chat identities, titles, and interactivity are projected into the session facade during listing without opening the per-session database. Observing chat-local transient details, including the default chat's modified time and peer chat status or activity, acquires the existing session-state subscription. The subscription reconciles those values onto the same stable chat facades and follows the observer lifetime before returning to the existing idle-release policy.
 
 ## Local and remote boundary