feat:Auto AI generated titles in extension

.changeset/ai-session-titles.md

@@ -0,0 +1,5 @@
+---
+"@nanocollective/nanocoder": minor
+---
+
+Added automatic session titles. A session keeps its opening prompt as the title, and when that prompt is too thin to be useful the agent generates a descriptive name once, after the first turn that ran a tool or the first follow-up message. Manual renames are never overwritten. Titling uses the session's own model by default - set `sessions.titleModel` / `sessions.titleProvider` to point it at a cheaper one, or `sessions.smartTitles: false` to turn it off. Also fixed the CLI's autosave deriving the session title from the latest user message and rewriting it on every save, which overwrote titles in the store the VS Code extension reads from. Closes #808.

plugins/vscode/src/acp-client.spec.ts

@@ -30,6 +30,21 @@ test('NanocoderAcpClient - permission flow', async (t) => {
 	t.false(client.hasPendingPermissions(), 'Pending permissions should be cleared');
 });
 
+test('NanocoderAcpClient - forwards background title notifications', async (t) => {
+	const client = makeClient({});
+	let notified = false;
+	client.onSessionTitleChanged = () => {
+		notified = true;
+	};
+
+	await client.handleExtNotification('_nanocoder/sessionTitleChanged', {
+		sessionId: 'session-1',
+		title: 'Updated title',
+	});
+
+	t.true(notified);
+});
+
 function makeClient(connection: unknown) {
 	const outputChannel = { appendLine: () => {} } as any;
 	const client = new NanocoderAcpClient(outputChannel, new AcpStateManager());

plugins/vscode/src/acp-client.ts

@@ -28,6 +28,8 @@ export class NanocoderAcpClient {
 	public onStateSync?: (state: StateSyncPayload) => void;
 	public onSessionArtifacts?: (meta: unknown) => void;
 	public onConnectionReady?: () => void;
+	/** Fires when a background title update is received. */
+	public onSessionTitleChanged?: () => void;
 
 	public currentMode?: string;
 	public availableModes: string[] = [];
@@ -90,6 +92,13 @@ export class NanocoderAcpClient {
 		this._clearPendingPermissions();
 	}
 
+	/** Handle custom notifications from the agent. */
+	async handleExtNotification(method: string, _params: unknown): Promise<void> {
+		if (method === '_nanocoder/sessionTitleChanged') {
+			this.onSessionTitleChanged?.();
+		}
+	}
+
 	async handlePermissionRequest(params: any): Promise<unknown> {
 		const toolCall = params.toolCall;
 		const toolCallId = toolCall.toolCallId;

plugins/vscode/src/acp-process-manager.ts

@@ -161,6 +161,9 @@ export class AcpProcessManager {
 			},
 			requestPermission: async (params: any) => {
 				return this.acpClient.handlePermissionRequest(params);
+			},
+			extNotification: async (method: string, params: any) => {
+				return this.acpClient.handleExtNotification(method, params);
 			}
 		} as any), stream);
 		this.acpClient.setConnection(connection);

plugins/vscode/src/chat-webview-provider.ts

@@ -114,6 +114,11 @@ export class ChatWebviewProvider
 			});
 		};
 
+		// Refresh the history list after a background title update.
+		this._acpClient.onSessionTitleChanged = () => {
+			void this._broadcastSessions();
+		};
+
 		this._acpClient.onConnectionReady = () => {
 			this._initializeSessionIfReady();
 		};

source/acp/acp-agent.spec.ts

@@ -798,6 +798,120 @@ test.serial(
 	},
 );
 
+// ============================================================================
+// background session titling
+// ============================================================================
+
+/** Poll the persisted session, since titling is deliberately fire and forget. */
+async function waitForSession(
+	sessionId: string,
+	predicate: (s: any) => boolean,
+	timeoutMs = 3000,
+): Promise<any | null> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		const s = await sessionManager.readSession(sessionId);
+		if (s && predicate(s)) return s;
+		await new Promise(r => setTimeout(r, 20));
+	}
+	return null;
+}
+
+test('AcpAgent.prompt - a weak title waits for meaningful context', async t => {
+	const {agent} = createAgent();
+
+	let chatCalls = 0;
+	agent['initContext'].client.chat = async () => {
+		chatCalls++;
+		// Calls 1 and 2 are conversation turns; call 3 is the titler.
+		return chatCalls < 3
+			? {choices: [{message: {content: 'Done.'}}]}
+			: {choices: [{message: {content: 'Fix Login Redirect'}}]};
+	};
+
+	const session = await agent.newSession({cwd: '/tmp'});
+	await agent.prompt({
+		sessionId: session.sessionId,
+		prompt: [{type: 'text', text: 'fix this'}],
+	});
+
+	await new Promise(r => setTimeout(r, 200));
+	const beforeContext = await sessionManager.readSession(session.sessionId);
+	t.not(beforeContext?.titleGenerated, true);
+	t.is(chatCalls, 1);
+
+	await agent.prompt({
+		sessionId: session.sessionId,
+		prompt: [{type: 'text', text: 'summarize the README'}],
+	});
+
+	const titled = await waitForSession(
+		session.sessionId,
+		s => s.titleGenerated === true,
+	);
+	t.truthy(titled, 'expected a generated title to be persisted');
+	t.is(titled.title, 'Fix Login Redirect');
+	// A generated title must never masquerade as a user rename.
+	t.not(titled.titleManuallySet, true);
+
+	// A third turn must not re-title: titleGenerated short-circuits it.
+	await agent.prompt({
+		sessionId: session.sessionId,
+		prompt: [{type: 'text', text: 'and now this'}],
+	});
+	await new Promise(r => setTimeout(r, 200));
+
+	const after = await sessionManager.readSession(session.sessionId);
+	t.is(after!.title, 'Fix Login Redirect');
+	// Exactly one more chat call, the conversation turn, and no second titler.
+	t.is(chatCalls, 4);
+});
+
+test('AcpAgent.prompt - a cancelled turn does not generate a title', async t => {
+	const {agent} = createAgent();
+
+	let chatCalls = 0;
+	agent['initContext'].client.chat = async () => {
+		chatCalls++;
+		throw new Error('Operation was cancelled');
+	};
+
+	const session = await agent.newSession({cwd: '/tmp'});
+	await agent.prompt({
+		sessionId: session.sessionId,
+		prompt: [{type: 'text', text: 'fix this'}],
+	});
+	await new Promise(r => setTimeout(r, 200));
+
+	// The cancel path early-returns from inside catch, which still runs the
+	// finally. Reaching the finally must not be mistaken for a clean turn.
+	t.is(chatCalls, 1);
+	const stored = await sessionManager.readSession(session.sessionId);
+	t.not(stored?.titleGenerated, true);
+});
+
+test('AcpAgent.prompt - an errored turn does not generate a title', async t => {
+	const {agent} = createAgent();
+
+	let chatCalls = 0;
+	agent['initContext'].client.chat = async () => {
+		chatCalls++;
+		throw new Error('RequestError: Internal error (500)');
+	};
+
+	const session = await agent.newSession({cwd: '/tmp'});
+	await t.throwsAsync(
+		agent.prompt({
+			sessionId: session.sessionId,
+			prompt: [{type: 'text', text: 'fix this'}],
+		}),
+	);
+	await new Promise(r => setTimeout(r, 200));
+
+	t.is(chatCalls, 1);
+	const stored = await sessionManager.readSession(session.sessionId);
+	t.not(stored?.titleGenerated, true);
+});
 /** Throwaway workspace for the timeline tests, removed by the caller. */
 const createTimelineWorkspace = (label: string): string => {
 	const cwd = join(

source/acp/acp-agent.ts

@@ -49,7 +49,9 @@ import {getAppConfig} from '@/config/index';
 import {loadPreferences, updateLastUsed} from '@/config/preferences';
 import {resolveTune} from '@/config/tune';
 import {TimelineManager} from '@/services/timeline-manager';
+import {maybeGenerateTitle} from '@/session/maybe-generate-title';
 import {sessionManager} from '@/session/session-manager';
+import {deriveTitleFromFirstMessage} from '@/session/title-generator';
 import {getTuneToolMode} from '@/types/config';
 import {getLogger} from '@/utils/logging';
 import {buildSystemPrompt, setLastBuiltPrompt} from '@/utils/prompt-builder';
@@ -338,14 +340,20 @@ export class AcpAgent implements Agent {
 		const nonInteractiveAlwaysAllow = config.alwaysAllow ?? [];
 
 		session.turnActive = true;
+		// Both the cancel early-return below and the rethrow after it still run
+		// the finally, so a clean turn has to be tracked explicitly rather than
+		// inferred from getting there.
+		let turnSucceeded = false;
 		try {
-			return await runAcpConversation({
+			const result = await runAcpConversation({
 				session,
 				client: this.initContext.client,
 				toolManager: this.initContext.toolManager,
 				conn: this.conn,
 				nonInteractiveAlwaysAllow,
 			});
+			turnSucceeded = true;
+			return result;
 		} catch (error) {
 			const errorMsg = error instanceof Error ? error.message : String(error);
 
@@ -395,6 +403,28 @@ export class AcpAgent implements Agent {
 			await this.saveAcpSessionToDisk(session).catch(err => {
 				logger.error(`Failed to save ACP session ${session.sessionId}: ${err}`);
 			});
+
+			// Fire and forget: the turn must return to idle immediately, and a
+			// cosmetic title landing a moment later is fine.
+			if (turnSucceeded) {
+				void maybeGenerateTitle({
+					sessionId: session.sessionId,
+					messages: session.messages,
+					client: this.initContext.client,
+					onTitle: title => {
+						// notify(), not the deprecated extNotification() alias.
+						// The client receives it as extNotification(method, params).
+						// Lands after the turn went idle, so the client may already be
+						// gone; an unhandled rejection here would kill the agent.
+						void this.conn
+							.notify('_nanocoder/sessionTitleChanged', {
+								sessionId: session.sessionId,
+								title,
+							})
+							.catch(() => {});
+					},
+				});
+			}
 		}
 	}
 
@@ -870,17 +900,17 @@ export class AcpAgent implements Agent {
 			let title = existingSession?.title;
 			if (!title || title === 'New Session') {
 				const firstUserMessage = saveableMessages.find(m => m.role === 'user');
-				if (firstUserMessage && typeof firstUserMessage.content === 'string') {
-					title = firstUserMessage.content.split('\n')[0].substring(0, 50);
-				} else {
-					title = 'New Session';
-				}
+				title =
+					(typeof firstUserMessage?.content === 'string'
+						? deriveTitleFromFirstMessage(firstUserMessage.content)
+						: null) ?? 'New Session';
 			}
 
 			await sessionManager.saveSession({
 				id: session.sessionId,
 				title,
 				titleManuallySet: existingSession?.titleManuallySet,
+				titleGenerated: existingSession?.titleGenerated,
 				createdAt: existingSession?.createdAt || timestamp,
 				lastAccessedAt: timestamp,
 				messageCount: saveableMessages.length,

source/acp/acp-ext-notification.spec.ts

@@ -0,0 +1,66 @@
+import test from 'ava';
+import {
+	AgentSideConnection,
+	ClientSideConnection,
+	ndJsonStream,
+} from '@agentclientprotocol/sdk';
+
+console.log('\nacp-ext-notification.spec.ts');
+
+/**
+ * The agent announces a generated session title with conn.notify(); the VS Code
+ * client is expected to receive it as extNotification(method, params).
+ *
+ * Every other test in this repo stubs the connection, so that dispatch has
+ * never actually crossed a wire. If the SDK routed it differently, the sidebar
+ * would silently never refresh while all the unit tests stayed green.
+ */
+test('a title notification sent with notify() arrives as extNotification', async t => {
+	const a2b = new TransformStream<Uint8Array, Uint8Array>();
+	const b2a = new TransformStream<Uint8Array, Uint8Array>();
+
+	const received: Array<{method: string; params: unknown}> = [];
+	let resolveReceived: () => void;
+	const gotOne = new Promise<void>(r => {
+		resolveReceived = r;
+	});
+
+	// Client side, mirroring how acp-process-manager builds its handler object.
+	new ClientSideConnection(
+		() =>
+			({
+				sessionUpdate: async () => {},
+				requestPermission: async () => ({outcome: {outcome: 'cancelled'}}),
+				extNotification: async (method: string, params: unknown) => {
+					received.push({method, params});
+					resolveReceived();
+				},
+			}) as never,
+		ndJsonStream(b2a.writable, a2b.readable),
+	);
+
+	// Agent side.
+	const agentConn = new AgentSideConnection(
+		() => ({}) as never,
+		ndJsonStream(a2b.writable, b2a.readable),
+	);
+
+	await agentConn.notify('_nanocoder/sessionTitleChanged', {
+		sessionId: 'session-1',
+		title: 'Fix Login Redirect',
+	});
+
+	await Promise.race([
+		gotOne,
+		new Promise((_r, reject) =>
+			setTimeout(() => reject(new Error('notification never arrived')), 3000),
+		),
+	]);
+
+	t.is(received.length, 1);
+	t.is(received[0].method, '_nanocoder/sessionTitleChanged');
+	t.deepEqual(received[0].params, {
+		sessionId: 'session-1',
+		title: 'Fix Login Redirect',
+	});
+});

source/config/index.ts

@@ -243,6 +243,7 @@ function loadSessionConfig(): AppConfig['sessions'] {
 		maxMessages: 1000,
 		retentionDays: 30,
 		directory: '',
+		smartTitles: true,
 	};
 
 	const normalizeSessionNumber = (
@@ -286,6 +287,19 @@ function loadSessionConfig(): AppConfig['sessions'] {
 						defaults.retentionDays ?? 30,
 					),
 					directory: sessions.directory || defaults.directory,
+					smartTitles:
+						sessions.smartTitles !== undefined
+							? Boolean(sessions.smartTitles)
+							: defaults.smartTitles,
+					// No default model: unset means "use the session's own".
+					titleModel:
+						typeof sessions.titleModel === 'string'
+							? sessions.titleModel
+							: undefined,
+					titleProvider:
+						typeof sessions.titleProvider === 'string'
+							? sessions.titleProvider
+							: undefined,
 				};
 			}
 			return null;