@agi-cli/server 0.1.73 → 0.1.75

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.73",
+	"version": "0.1.75",
 	"description": "HTTP API server for AGI CLI",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,8 +29,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@agi-cli/sdk": "0.1.73",
-		"@agi-cli/database": "0.1.73",
+		"@agi-cli/sdk": "0.1.75",
+		"@agi-cli/database": "0.1.75",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/routes/session-messages.ts

@@ -85,6 +85,17 @@ export function registerSessionMessagesRoutes(app: Hono) {
 			const db = await getDb(cfg.projectRoot);
 			const sessionId = c.req.param('id');
 			const body = await c.req.json().catch(() => ({}));
+
+			// DEBUG: Log received body
+			logger.info('[API] Received message request', {
+				sessionId,
+				hasContent: !!body?.content,
+				hasUserContext: !!body?.userContext,
+				userContext: body?.userContext
+					? `${String(body.userContext).substring(0, 50)}...`
+					: 'NONE',
+			});
+
 			// Load session to inherit its provider/model/agent by default
 			const sessionRows = await db
 				.select()
@@ -99,6 +110,15 @@ export function registerSessionMessagesRoutes(app: Hono) {
 			const modelName = body?.model ?? sess.model ?? cfg.defaults.model;
 			const agent = body?.agent ?? sess.agent ?? cfg.defaults.agent;
 			const content = body?.content ?? '';
+			const userContext = body?.userContext;
+
+			// DEBUG: Log extracted userContext
+			logger.info('[API] Extracted userContext', {
+				userContext: userContext
+					? `${String(userContext).substring(0, 50)}...`
+					: 'NONE',
+				typeOf: typeof userContext,
+			});
 
 			// Validate model capabilities if tools are allowed for this agent
 			const wantsToolCalls = true; // agent toolset may be non-empty
@@ -131,6 +151,7 @@ export function registerSessionMessagesRoutes(app: Hono) {
 				model: modelName,
 				content,
 				oneShot: Boolean(body?.oneShot),
+				userContext,
 			});
 			return c.json({ messageId: assistantMessageId }, 202);
 		} catch (error) {

package/src/runtime/api-error.ts

@@ -70,8 +70,14 @@ export function serializeError(err: unknown): APIErrorResponse {
 	const payload = toErrorPayload(err);
 
 	// Determine HTTP status code
-	let status = 500;
-	if (err && typeof err === 'object') {
+	// Default to 400 for generic errors (client errors)
+	// Only use 500 if explicitly set or for APIError instances without a status
+	let status = 400;
+
+	// Handle APIError instances first
+	if (err instanceof APIError) {
+		status = err.status;
+	} else if (err && typeof err === 'object') {
 		const errObj = err as Record<string, unknown>;
 		if (typeof errObj.status === 'number') {
 			status = errObj.status;
@@ -86,11 +92,6 @@ export function serializeError(err: unknown): APIErrorResponse {
 		}
 	}
 
-	// Handle APIError instances
-	if (err instanceof APIError) {
-		status = err.status;
-	}
-
 	// Extract code if available
 	let code: string | undefined;
 	if (err && typeof err === 'object') {

package/src/runtime/message-service.ts

@@ -20,13 +20,29 @@ type DispatchOptions = {
 	model: string;
 	content: string;
 	oneShot?: boolean;
+	userContext?: string;
 };
 
 export async function dispatchAssistantMessage(
 	options: DispatchOptions,
 ): Promise<{ assistantMessageId: string }> {
-	const { cfg, db, session, agent, provider, model, content, oneShot } =
-		options;
+	const {
+		cfg,
+		db,
+		session,
+		agent,
+		provider,
+		model,
+		content,
+		oneShot,
+		userContext,
+	} = options;
+
+	// DEBUG: Log userContext in dispatch
+	debugLog(
+		`[MESSAGE_SERVICE] dispatchAssistantMessage called with userContext: ${userContext ? userContext.substring(0, 50) + '...' : 'NONE'}`,
+	);
+
 	const sessionId = session.id;
 	const now = Date.now();
 	const userMessageId = crypto.randomUUID();
@@ -90,6 +106,11 @@ export async function dispatchAssistantMessage(
 		payload: { id: assistantMessageId, role: 'assistant' },
 	});
 
+	// DEBUG: Log before enqueue
+	debugLog(
+		`[MESSAGE_SERVICE] Enqueuing assistant run with userContext: ${userContext ? userContext.substring(0, 50) + '...' : 'NONE'}`,
+	);
+
 	enqueueAssistantRun({
 		sessionId,
 		assistantMessageId,
@@ -99,6 +120,7 @@ export async function dispatchAssistantMessage(
 		model,
 		projectRoot: cfg.projectRoot,
 		oneShot: Boolean(oneShot),
+		userContext,
 	});
 
 	void touchSessionLastActive({ db, sessionId });
@@ -117,21 +139,44 @@ function scheduleSessionTitle(args: {
 	db: DB;
 	sessionId: string;
 	content: unknown;
-}): void {
-	const { sessionId } = args;
-	if (titleInFlight.has(sessionId)) return;
-	titleInFlight.add(sessionId);
-	void (async () => {
+}) {
+	const { cfg, db, sessionId, content } = args;
+
+	if (titleInFlight.has(sessionId) || titlePending.has(sessionId)) {
+		return;
+	}
+
+	const processNext = () => {
+		if (titleQueue.length === 0) {
+			return;
+		}
+		if (titleActiveCount >= TITLE_CONCURRENCY_LIMIT) {
+			return;
+		}
+		const next = titleQueue.shift();
+		if (!next) return;
+		titleActiveCount++;
+		next();
+	};
+
+	const task = async () => {
+		titleInFlight.add(sessionId);
+		titlePending.delete(sessionId);
 		try {
-			const alreadyTitled = await sessionHasTitle(args.db, sessionId);
-			if (alreadyTitled) return;
-			await withTitleSlot(() => updateSessionTitle(args));
-		} catch {
-			// Swallow title generation errors; they are non-blocking.
+			await generateSessionTitle({ cfg, db, sessionId, content });
+		} catch (err) {
+			debugLog('[TITLE_GEN] Title generation error:');
+			debugLog(err);
 		} finally {
 			titleInFlight.delete(sessionId);
+			titleActiveCount--;
+			processNext();
 		}
-	})();
+	};
+
+	titlePending.add(sessionId);
+	titleQueue.push(task);
+	processNext();
 }
 
 function enqueueSessionTitle(args: {
@@ -140,72 +185,54 @@ function enqueueSessionTitle(args: {
 	sessionId: string;
 	content: unknown;
 }) {
-	const { sessionId } = args;
-	if (titlePending.has(sessionId) || titleInFlight.has(sessionId)) return;
-	titlePending.add(sessionId);
-	Promise.resolve()
-		.then(() => {
-			titlePending.delete(sessionId);
-			scheduleSessionTitle(args);
-		})
-		.catch(() => {
-			titlePending.delete(sessionId);
-		});
+	scheduleSessionTitle(args);
 }
 
-async function updateSessionTitle(args: {
+async function generateSessionTitle(args: {
 	cfg: AGIConfig;
 	db: DB;
 	sessionId: string;
 	content: unknown;
-}) {
+}): Promise<void> {
 	const { cfg, db, sessionId, content } = args;
+
 	try {
-		const rows = await db
+		const existingSession = await db
 			.select()
 			.from(sessions)
 			.where(eq(sessions.id, sessionId));
-		if (!rows.length) return;
-		const current = rows[0];
-		const alreadyHasTitle =
-			current.title != null && String(current.title).trim().length > 0;
-		let heuristic = '';
-		if (!alreadyHasTitle) {
-			heuristic = deriveTitle(String(content ?? ''));
-			if (heuristic) {
-				await db
-					.update(sessions)
-					.set({ title: heuristic })
-					.where(eq(sessions.id, sessionId));
-				publish({
-					type: 'session.updated',
-					sessionId,
-					payload: { title: heuristic },
-				});
-			}
+
+		if (!existingSession.length) {
+			debugLog('[TITLE_GEN] Session not found, aborting');
+			return;
+		}
+
+		const sess = existingSession[0];
+		if (sess.title && sess.title !== 'New Session') {
+			debugLog('[TITLE_GEN] Session already has a title, skipping');
+			return;
 		}
 
-		const providerId =
-			(current.provider as ProviderId) ?? cfg.defaults.provider;
-		const modelId = current.model ?? cfg.defaults.model;
+		const provider = sess.provider ?? cfg.defaults.provider;
+		const modelName = sess.model ?? cfg.defaults.model;
 
-		debugLog('[TITLE_GEN] Starting title generation');
-		debugLog(`[TITLE_GEN] Provider: ${providerId}, Model: ${modelId}`);
+		debugLog('[TITLE_GEN] Generating title for session');
+		debugLog(`[TITLE_GEN] Provider: ${provider}, Model: ${modelName}`);
+
+		const model = await resolveModel(provider, modelName, cfg);
 
-		// Check if we need OAuth spoof prompt (same logic as runner)
 		const { getAuth } = await import('@agi-cli/sdk');
 		const { getProviderSpoofPrompt } = await import('./prompt.ts');
-		const auth = await getAuth(providerId, cfg.projectRoot);
+		const auth = await getAuth(provider, cfg.projectRoot);
 		const needsSpoof = auth?.type === 'oauth';
 		const spoofPrompt = needsSpoof
-			? getProviderSpoofPrompt(providerId)
+			? getProviderSpoofPrompt(provider)
 			: undefined;
 
-		debugLog(`[TITLE_GEN] Auth type: ${auth?.type ?? 'none'}`);
-		debugLog(`[TITLE_GEN] Needs spoof: ${needsSpoof}`);
-		debugLog(`[TITLE_GEN] Spoof prompt length: ${spoofPrompt?.length ?? 0}`);
+		debugLog(
+			`[TITLE_GEN] needsSpoof: ${needsSpoof}, spoofPrompt: ${spoofPrompt || 'NONE'}`,
+		);
 
-		const model = await resolveModel(providerId, modelId, cfg);
 		const promptText = String(content ?? '').slice(0, 2000);
 
 		const titlePrompt = [
@@ -270,123 +297,49 @@ async function updateSessionTitle(args: {
 		const sanitized = sanitizeTitle(modelTitle);
 		debugLog(`[TITLE_GEN] After sanitization: "${sanitized}"`);
 
-		if (!sanitized) {
-			debugLog('[TITLE_GEN] Title sanitized to empty, aborting');
-			return;
-		}
-
-		modelTitle = sanitized;
-
-		const check = await db
-			.select()
-			.from(sessions)
-			.where(eq(sessions.id, sessionId));
-		if (!check.length) return;
-		const currentTitle = String(check[0].title ?? '').trim();
-		if (currentTitle && currentTitle !== heuristic) {
-			debugLog(
-				`[TITLE_GEN] Session already has different title: "${currentTitle}", skipping`,
-			);
+		if (!sanitized || sanitized === 'New Session') {
+			debugLog('[TITLE_GEN] Sanitized title is empty or default, aborting');
 			return;
 		}
 
-		debugLog(`[TITLE_GEN] Setting final title: "${modelTitle}"`);
 		await db
 			.update(sessions)
-			.set({ title: modelTitle })
+			.set({ title: sanitized, updatedAt: Date.now() })
 			.where(eq(sessions.id, sessionId));
+
+		debugLog(`[TITLE_GEN] Setting final title: "${sanitized}"`);
+
 		publish({
 			type: 'session.updated',
 			sessionId,
-			payload: { title: modelTitle },
+			payload: { id: sessionId, title: sanitized },
 		});
 	} catch (err) {
-		debugLog('[TITLE_GEN] Fatal error:');
+		debugLog('[TITLE_GEN] Error in generateSessionTitle:');
 		debugLog(err);
 	}
 }
 
-async function withTitleSlot<T>(fn: () => Promise<T>): Promise<T> {
-	await acquireTitleSlot();
-	try {
-		return await fn();
-	} finally {
-		releaseTitleSlot();
-	}
-}
-
-async function sessionHasTitle(db: DB, sessionId: string): Promise<boolean> {
-	try {
-		const rows = await db
-			.select({ title: sessions.title })
-			.from(sessions)
-			.where(eq(sessions.id, sessionId))
-			.limit(1);
-		if (!rows.length) return false;
-		const title = rows[0]?.title;
-		return typeof title === 'string' && title.trim().length > 0;
-	} catch {
-		return false;
-	}
-}
-
-function acquireTitleSlot(): Promise<void> {
-	if (titleActiveCount < TITLE_CONCURRENCY_LIMIT) {
-		titleActiveCount += 1;
-		return Promise.resolve();
-	}
-	return new Promise((resolve) => {
-		titleQueue.push(() => {
-			titleActiveCount += 1;
-			resolve();
-		});
-	});
-}
-
-function releaseTitleSlot(): void {
-	if (titleActiveCount > 0) titleActiveCount -= 1;
-	const next = titleQueue.shift();
-	if (next) {
-		next();
-	}
+function sanitizeTitle(raw: string): string {
+	let s = raw.trim();
+	s = s.replace(/^["']|["']$/g, '');
+	s = s.replace(/[.!?]+$/, '');
+	s = s.replace(/\s+/g, ' ');
+	if (s.length > 80) s = s.slice(0, 80).trim();
+	return s;
 }
 
-async function touchSessionLastActive(args: { db: DB; sessionId: string }) {
+async function touchSessionLastActive(args: {
+	db: DB;
+	sessionId: string;
+}): Promise<void> {
 	const { db, sessionId } = args;
 	try {
 		await db
 			.update(sessions)
-			.set({ lastActiveAt: Date.now() })
+			.set({ updatedAt: Date.now() })
 			.where(eq(sessions.id, sessionId));
-	} catch {}
-}
-
-function deriveTitle(text: string): string {
-	const cleaned = String(text || '')
-		.replace(/```[\s\S]*?```/g, ' ')
-		.replace(/`[^`]*`/g, ' ')
-		.replace(/\s+/g, ' ')
-		.trim();
-	if (!cleaned) return '';
-	const endIdx = (() => {
-		const punct = ['? ', '. ', '! ']
-			.map((p) => cleaned.indexOf(p))
-			.filter((i) => i > 0);
-		const idx = Math.min(...(punct.length ? punct : [cleaned.length]));
-		return Math.min(idx + 1, cleaned.length);
-	})();
-	const first = cleaned.slice(0, endIdx).trim();
-	const maxLen = 64;
-	const base = first.length > 8 ? first : cleaned;
-	const truncated =
-		base.length > maxLen ? `${base.slice(0, maxLen - 1).trimEnd()}…` : base;
-	return truncated;
-}
-
-function sanitizeTitle(s: string): string {
-	let t = s.trim();
-	t = t.replace(/^['"""''()[\]]+|['"""''()[\]]+$/g, '').trim();
-	t = t.replace(/[\s\-_:–—]+$/g, '').trim();
-	if (t.length > 64) t = `${t.slice(0, 63).trimEnd()}…`;
-	return t;
+	} catch (err) {
+		debugLog('[touchSessionLastActive] Error:', err);
+	}
 }

package/src/runtime/prompt.ts

@@ -20,6 +20,7 @@ export async function composeSystemPrompt(options: {
 	spoofPrompt?: string;
 	includeEnvironment?: boolean;
 	includeProjectTree?: boolean;
+	userContext?: string;
 }): Promise<string> {
 	if (options.spoofPrompt) {
 		return options.spoofPrompt.trim();
@@ -61,6 +62,16 @@ export async function composeSystemPrompt(options: {
 		}
 	}
 
+	// Add user-provided context if present
+	if (options.userContext?.trim()) {
+		const userContextBlock = [
+			'<user-provided-state-context>',
+			options.userContext.trim(),
+			'</user-provided-state-context>',
+		].join('\n');
+		parts.push(userContextBlock);
+	}
+
 	const composed = parts.filter(Boolean).join('\n\n').trim();
 	if (composed) return composed;
 

package/src/runtime/runner.ts

@@ -122,7 +122,18 @@ async function runAssistant(opts: RunOpts) {
 	const history = await buildHistoryMessages(db, opts.sessionId);
 	historyTimer.end({ messages: history.length });
 
-	const isFirstMessage = history.length === 0;
+	// FIX: For OAuth, we need to check if this is the first ASSISTANT message
+	// The user message is already in history by this point, so history.length will be > 0
+	// We need to add additionalSystemMessages on the first assistant turn
+	const isFirstMessage = !history.some((m) => m.role === 'assistant');
+
+	debugLog(`[RUNNER] isFirstMessage: ${isFirstMessage}`);
+	debugLog(`[RUNNER] userContext provided: ${opts.userContext ? 'YES' : 'NO'}`);
+	if (opts.userContext) {
+		debugLog(
+			`[RUNNER] userContext value: ${opts.userContext.substring(0, 100)}${opts.userContext.length > 100 ? '...' : ''}`,
+		);
+	}
 
 	const systemTimer = time('runner:composeSystemPrompt');
 	const { getAuth } = await import('@agi-cli/sdk');
@@ -133,10 +144,14 @@ async function runAssistant(opts: RunOpts) {
 		? getProviderSpoofPrompt(opts.provider)
 		: undefined;
 
+	debugLog(`[RUNNER] needsSpoof (OAuth): ${needsSpoof}`);
+	debugLog(`[RUNNER] spoofPrompt: ${spoofPrompt || 'NONE'}`);
+
 	let system: string;
 	let additionalSystemMessages: Array<{ role: 'system'; content: string }> = [];
 
 	if (spoofPrompt) {
+		// OAuth mode: short spoof in system field, full instructions in messages array
 		system = spoofPrompt;
 		const fullPrompt = await composeSystemPrompt({
 			provider: opts.provider,
@@ -146,9 +161,27 @@ async function runAssistant(opts: RunOpts) {
 			oneShot: opts.oneShot,
 			spoofPrompt: undefined,
 			includeProjectTree: isFirstMessage,
+			userContext: opts.userContext,
 		});
+
+		// FIX: Always add the system message for OAuth because:
+		// 1. System messages are NOT stored in the database
+		// 2. buildHistoryMessages only returns user/assistant messages
+		// 3. We need the full instructions on every turn
 		additionalSystemMessages = [{ role: 'system', content: fullPrompt }];
+
+		debugLog('[RUNNER] OAuth mode: additionalSystemMessages created');
+		debugLog(`[RUNNER] fullPrompt length: ${fullPrompt.length}`);
+		debugLog(
+			`[RUNNER] fullPrompt contains userContext: ${fullPrompt.includes('<user-provided-state-context>') ? 'YES' : 'NO'}`,
+		);
+		if (opts.userContext && fullPrompt.includes(opts.userContext)) {
+			debugLog('[RUNNER] ✅ userContext IS in fullPrompt');
+		} else if (opts.userContext) {
+			debugLog('[RUNNER] ❌ userContext NOT in fullPrompt!');
+		}
 	} else {
+		// API key mode: full instructions in system field
 		system = await composeSystemPrompt({
 			provider: opts.provider,
 			model: opts.model,
@@ -157,6 +190,7 @@ async function runAssistant(opts: RunOpts) {
 			oneShot: opts.oneShot,
 			spoofPrompt: undefined,
 			includeProjectTree: isFirstMessage,
+			userContext: opts.userContext,
 		});
 	}
 	systemTimer.end();
@@ -172,11 +206,29 @@ async function runAssistant(opts: RunOpts) {
 		'progress_update',
 	]);
 	const gated = allTools.filter((t) => allowedNames.has(t.name));
+
+	// FIX: For OAuth, ALWAYS prepend the system message because it's never in history
+	// For API key mode, only add on first message (when additionalSystemMessages is empty)
 	const messagesWithSystemInstructions = [
-		...(isFirstMessage ? additionalSystemMessages : []),
+		...additionalSystemMessages, // Always add for OAuth, empty for API key mode
 		...history,
 	];
 
+	debugLog(
+		`[RUNNER] messagesWithSystemInstructions length: ${messagesWithSystemInstructions.length}`,
+	);
+	debugLog(
+		`[RUNNER] additionalSystemMessages length: ${additionalSystemMessages.length}`,
+	);
+	if (additionalSystemMessages.length > 0) {
+		debugLog(
+			'[RUNNER] ✅ additionalSystemMessages ADDED to messagesWithSystemInstructions',
+		);
+		debugLog(
+			`[RUNNER] This happens on EVERY turn for OAuth (system messages not stored in DB)`,
+		);
+	}
+
 	const { sharedCtx, firstToolTimer, firstToolSeen } = await setupToolContext(
 		opts,
 		db,
@@ -257,9 +309,24 @@ async function runAssistant(opts: RunOpts) {
 		maxToolResults: 30,
 	});
 
+	debugLog(
+		`[RUNNER] After optimizeContext: ${contextOptimized.length} messages`,
+	);
+
 	// 2. Truncate history
 	const truncatedMessages = truncateHistory(contextOptimized, 20);
 
+	debugLog(
+		`[RUNNER] After truncateHistory: ${truncatedMessages.length} messages`,
+	);
+	if (truncatedMessages.length > 0 && truncatedMessages[0].role === 'system') {
+		debugLog('[RUNNER] ✅ First message is system message');
+	} else if (truncatedMessages.length > 0) {
+		debugLog(
+			`[RUNNER] ⚠️ First message is NOT system (it's ${truncatedMessages[0].role})`,
+		);
+	}
+
 	// 3. Add cache control
 	const { system: cachedSystem, messages: optimizedMessages } = addCacheControl(
 		opts.provider,
@@ -267,6 +334,13 @@ async function runAssistant(opts: RunOpts) {
 		truncatedMessages,
 	);
 
+	debugLog(
+		`[RUNNER] Final optimizedMessages: ${optimizedMessages.length} messages`,
+	);
+	debugLog(
+		`[RUNNER] cachedSystem (spoof): ${typeof cachedSystem === 'string' ? cachedSystem.substring(0, 100) : JSON.stringify(cachedSystem).substring(0, 100)}`,
+	);
+
 	try {
 		// @ts-expect-error this is fine 🔥
 		const result = streamText({
@@ -310,29 +384,23 @@ async function runAssistant(opts: RunOpts) {
 		await db
 			.update(messageParts)
 			.set({
-				content: JSON.stringify({
-					text: accumulated,
-					error: errorPayload.message,
-				}),
+				content: JSON.stringify({ error: errorPayload }),
 			})
-			.where(eq(messageParts.messageId, opts.assistantMessageId));
+			.where(eq(messageParts.id, currentPartId));
+
 		publish({
-			type: 'error',
+			type: 'message.error',
 			sessionId: opts.sessionId,
 			payload: {
 				messageId: opts.assistantMessageId,
-				error: errorPayload.message,
-				details: errorPayload.details,
+				partId: currentPartId,
+				error: errorPayload,
 			},
 		});
 		throw error;
 	} finally {
-		if (!firstToolSeen()) firstToolTimer.end({ skipped: true });
-		try {
-			unsubscribeFinish();
-		} catch {}
-		try {
-			await cleanupEmptyTextParts(opts, db);
-		} catch {}
+		unsubscribeFinish();
+		await cleanupEmptyTextParts(db, opts.assistantMessageId);
+		firstToolTimer.end({ seen: firstToolSeen });
 	}
 }

package/src/runtime/session-queue.ts

@@ -9,6 +9,7 @@ export type RunOpts = {
 	model: string;
 	projectRoot: string;
 	oneShot?: boolean;
+	userContext?: string;
 	abortSignal?: AbortSignal;
 };
 
@@ -39,7 +40,8 @@ export function enqueueAssistantRun(
 }
 
 /**
- * Aborts all pending operations for a given session.
+ * Signals the abort controller for a session.
+ * This will trigger the abortSignal in the streamText call.
  */
 export function abortSession(sessionId: string) {
 	const controller = sessionAbortControllers.get(sessionId);
@@ -49,34 +51,25 @@ export function abortSession(sessionId: string) {
 	}
 }
 
-/**
- * Gets the current state of a session's queue.
- */
 export function getRunnerState(sessionId: string): RunnerState | undefined {
 	return runners.get(sessionId);
 }
 
-/**
- * Marks a session queue as running.
- */
 export function setRunning(sessionId: string, running: boolean) {
 	const state = runners.get(sessionId);
-	if (state) {
-		state.running = running;
-	}
+	if (state) state.running = running;
 }
 
-/**
- * Dequeues the next job from a session's queue.
- */
 export function dequeueJob(sessionId: string): RunOpts | undefined {
 	const state = runners.get(sessionId);
 	return state?.queue.shift();
 }
 
-/**
- * Cleanup abort controller for a session (called when queue is done).
- */
 export function cleanupSession(sessionId: string) {
-	sessionAbortControllers.delete(sessionId);
+	const state = runners.get(sessionId);
+	if (state && state.queue.length === 0 && !state.running) {
+		runners.delete(sessionId);
+		// Clean up any lingering abort controller
+		sessionAbortControllers.delete(sessionId);
+	}
 }