@ottocode/server 0.1.233 → 0.1.235

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.233",
+	"version": "0.1.235",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -49,8 +49,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/sdk": "0.1.233",
-		"@ottocode/database": "0.1.233",
+		"@ottocode/sdk": "0.1.235",
+		"@ottocode/database": "0.1.235",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.3.6"

package/src/routes/config/utils.ts

@@ -83,11 +83,7 @@ export async function discoverAllAgents(
 				agentSet.add(agentName);
 			}
 		}
-	} catch (err) {
-		logger.debug('Failed to load agents.json', {
-			error: err instanceof Error ? err.message : String(err),
-		});
-	}
+	} catch {}
 
 	try {
 		const localAgentsPath = join(projectRoot, '.otto', 'agents');
@@ -100,11 +96,7 @@ export async function discoverAllAgents(
 				}
 			}
 		}
-	} catch (err) {
-		logger.debug('Failed to read local agents directory', {
-			error: err instanceof Error ? err.message : String(err),
-		});
-	}
+	} catch {}
 
 	try {
 		const globalAgentsPath = getGlobalAgentsDir();
@@ -117,11 +109,7 @@ export async function discoverAllAgents(
 				}
 			}
 		}
-	} catch (err) {
-		logger.debug('Failed to read global agents directory', {
-			error: err instanceof Error ? err.message : String(err),
-		});
-	}
+	} catch {}
 
 	return Array.from(agentSet).sort();
 }

package/src/routes/git/commit.ts

@@ -10,7 +10,6 @@ import { sessions } from '@ottocode/database/schema';
 import { gitCommitSchema, gitGenerateCommitMessageSchema } from './schemas.ts';
 import { validateAndGetGitRoot, parseGitStatus } from './utils.ts';
 import { resolveModel } from '../../runtime/provider/index.ts';
-import { debugLog } from '../../runtime/debug/index.ts';
 import {
 	detectOAuth,
 	adaptSimpleCall,
@@ -168,7 +167,6 @@ Commit message:`;
 			});
 
 			if (adapted.forceStream) {
-				debugLog('[COMMIT] Using streamText for OpenAI OAuth');
 				const result = streamText({
 					model,
 					system: adapted.system,
@@ -180,7 +178,6 @@ Commit message:`;
 					text += chunk;
 				}
 				const message = text.trim();
-				debugLog(`[COMMIT] OAuth result: "${message.slice(0, 80)}..."`);
 				return c.json({ status: 'ok', data: { message } });
 			}
 

package/src/routes/terminals.ts

@@ -18,9 +18,7 @@ export function registerTerminalsRoutes(
 
 	app.post('/v1/terminals', async (c) => {
 		try {
-			logger.debug('POST /v1/terminals called');
 			const body = await c.req.json();
-			logger.debug('Creating terminal request received', body);
 			const { command, args, purpose, cwd, title } = body;
 
 			if (!command || !purpose) {
@@ -36,13 +34,6 @@ export function registerTerminalsRoutes(
 			}
 			const resolvedCwd = cwd || process.cwd();
 
-			logger.debug('Creating terminal', {
-				command: resolvedCommand,
-				args,
-				purpose,
-				cwd: resolvedCwd,
-			});
-
 			const terminal = terminalManager.create({
 				command: resolvedCommand,
 				args: args || [],
@@ -52,8 +43,6 @@ export function registerTerminalsRoutes(
 				title,
 			});
 
-			logger.debug('Terminal created successfully', { id: terminal.id });
-
 			return c.json({
 				terminalId: terminal.id,
 				pid: terminal.pid,
@@ -80,25 +69,18 @@ export function registerTerminalsRoutes(
 
 	const handleTerminalOutput = async (c: Context) => {
 		const id = c.req.param('id');
-		logger.debug('SSE client connecting to terminal', { id });
 		const terminal = terminalManager.get(id);
 
 		if (!terminal) {
-			logger.debug('SSE terminal not found', { id });
 			return c.json({ error: 'Terminal not found' }, 404);
 		}
 
 		const activeTerminal = terminal;
 
 		return streamSSE(c, async (stream) => {
-			logger.debug('SSE stream started for terminal', { id });
 			const skipHistory = c.req.query('skipHistory') === 'true';
 			if (!skipHistory) {
 				const history = activeTerminal.read();
-				logger.debug('SSE sending terminal history', {
-					id,
-					lines: history.length,
-				});
 				for (const line of history) {
 					await stream.write(
 						`data: ${JSON.stringify({ type: 'data', line })}\n\n`,
@@ -155,9 +137,6 @@ export function registerTerminalsRoutes(
 			}
 
 			function onAbort() {
-				logger.debug('SSE client disconnected from terminal', {
-					id: activeTerminal.id,
-				});
 				stream.close();
 				finish();
 			}

package/src/routes/tunnel.ts

@@ -47,8 +47,6 @@ export function registerTunnelRoutes(app: Hono) {
 				port = getServerPort() || 9100;
 			}
 
-			logger.debug('Starting tunnel on port:', port);
-
 			// Kill any stale tunnel processes first
 			await killStaleTunnels();
 
@@ -60,7 +58,6 @@ export function registerTunnelRoutes(app: Hono) {
 
 			const url = await activeTunnel.start(port, (msg) => {
 				progressMessage = msg;
-				logger.debug('Tunnel progress', { message: msg });
 			});
 
 			tunnelUrl = url;
@@ -109,8 +106,6 @@ export function registerTunnelRoutes(app: Hono) {
 			tunnelError = null;
 			progressMessage = null;
 
-			logger.debug('External tunnel registered:', url);
-
 			return c.json({
 				ok: true,
 				url: tunnelUrl,

package/src/runtime/agent/mcp-prepare-step.ts

@@ -1,5 +1,4 @@
 import type { Tool } from 'ai';
-import { debugLog } from '../debug/index.ts';
 
 export interface MCPPrepareStepState {
 	mcpToolsRecord: Record<string, Tool>;
@@ -57,12 +56,7 @@ export function buildPrepareStep(state: MCPPrepareStepState) {
 		}
 
 		const activeTools = [...state.baseToolNames, ...state.loadedMCPTools];
-
-		if (state.loadedMCPTools.size > 0) {
-			debugLog(
-				`[MCP prepareStep] step=${stepNumber}, active MCP tools: ${[...state.loadedMCPTools].join(', ')}`,
-			);
-		}
+		void stepNumber;
 
 		return { activeTools };
 	};

package/src/runtime/agent/registry.ts

@@ -1,5 +1,4 @@
 import { getGlobalAgentsJsonPath, getGlobalAgentsDir } from '@ottocode/sdk';
-import { debugLog } from '../debug/index.ts';
 import type { ProviderName } from '@ottocode/sdk';
 import { catalog } from '@ottocode/sdk';
 // Embed default agent prompts; only user overrides read from disk.
@@ -334,13 +333,7 @@ export async function resolveAgentConfig(
 	const deduped = Array.from(new Set([...tools, ...baseToolSet]));
 	const provider = normalizeProvider(entry?.provider);
 	const model = normalizeModel(entry?.model);
-	debugLog(`[agent] ${name} prompt source: ${promptSource}`);
-	debugLog(
-		`[agent] ${name} prompt summary: ${JSON.stringify({
-			length: prompt.length,
-			lines: prompt.split('\n').length,
-		})}`,
-	);
+	void promptSource;
 	return {
 		name,
 		prompt,

package/src/runtime/agent/runner-setup.ts

@@ -11,7 +11,7 @@ import { discoverProjectTools } from '@ottocode/sdk';
 import type { Tool } from 'ai';
 import { adaptTools } from '../../tools/adapter.ts';
 import { buildDatabaseTools } from '../../tools/database/index.ts';
-import { debugLog, time } from '../debug/index.ts';
+import { time } from '../debug/index.ts';
 import { isDevtoolsEnabled } from '../debug/state.ts';
 import { buildHistoryMessages } from '../message/history-builder.ts';
 import { getMaxOutputTokens } from '../utils/token.ts';
@@ -87,7 +87,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const historyTimer = time('runner:buildHistory');
 	let history: Awaited<ReturnType<typeof buildHistoryMessages>>;
 	if (opts.isCompactCommand && opts.compactionContext) {
-		debugLog('[RUNNER] Using minimal history for /compact command');
 		history = [];
 	} else {
 		history = await buildHistoryMessages(
@@ -104,34 +103,14 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		.where(eq(sessions.id, opts.sessionId))
 		.limit(1);
 	const contextSummary = sessionRows[0]?.contextSummary ?? undefined;
-	if (contextSummary) {
-		debugLog(
-			`[RUNNER] Using context summary from compaction (${contextSummary.length} chars)`,
-		);
-	}
 
 	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('@ottocode/sdk');
 	const auth = await getAuth(opts.provider, cfg.projectRoot);
 	const oauth = detectOAuth(opts.provider, auth);
 
-	debugLog(
-		`[RUNNER] needsSpoof (OAuth): ${oauth.needsSpoof}, isOpenAIOAuth: ${oauth.isOpenAIOAuth}`,
-	);
-	debugLog(
-		`[RUNNER] spoofPrompt: ${oauth.spoofPrompt ? `present (${opts.provider})` : 'none'}`,
-	);
-
 	const composed = await composeSystemPrompt({
 		provider: opts.provider,
 		model: opts.model,
@@ -155,15 +134,8 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const { system } = adapted;
 	const { systemComponents, additionalSystemMessages } = adapted;
 	systemTimer.end();
-	debugLog(
-		`[system] summary: ${JSON.stringify({
-			components: systemComponents,
-			length: system.length,
-		})}`,
-	);
 
 	if (opts.isCompactCommand && opts.compactionContext) {
-		debugLog('[RUNNER] Injecting compaction context for /compact command');
 		const compactPrompt = getCompactionSystemPrompt();
 		additionalSystemMessages.push({
 			role: 'system',
@@ -188,9 +160,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		for (const dt of dbTools) {
 			discovered.tools.push(dt);
 		}
-		debugLog(
-			`[tools] Added ${dbTools.length} database tools for research agent (parent: ${parentSessionId ?? 'none'})`,
-		);
 	}
 
 	toolsTimer.end({
@@ -200,12 +169,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const gated = allTools.filter(
 		(tool) => allowedNames.has(tool.name) || tool.name === 'load_mcp_tools',
 	);
-	debugLog(
-		`[tools] ${gated.length} gated tools, ${Object.keys(mcpToolsRecord).length} lazy MCP tools`,
-	);
-
-	debugLog(`[RUNNER] About to create model with provider: ${opts.provider}`);
-	debugLog(`[RUNNER] About to create model ID: ${opts.model}`);
 
 	const model = await resolveModel(opts.provider, opts.model, cfg, {
 		sessionId: opts.sessionId,
@@ -218,12 +181,8 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 				middleware: devToolsMiddleware(),
 			})
 		: model;
-	debugLog(
-		`[RUNNER] Model created: ${JSON.stringify({ id: model.modelId, provider: model.provider })}`,
-	);
 
 	const maxOutputTokens = adapted.maxOutputTokens;
-	debugLog(`[RUNNER] maxOutputTokens for ${opts.model}: ${maxOutputTokens}`);
 
 	const { sharedCtx, firstToolTimer, firstToolSeen } = await setupToolContext(
 		opts,
@@ -253,12 +212,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	});
 	mergeProviderOptions(providerOptions, reasoningConfig.providerOptions);
 	effectiveMaxOutputTokens = reasoningConfig.effectiveMaxOutputTokens;
-	debugLog(
-		`[RUNNER] reasoning enabled for ${opts.provider}/${opts.model}: ${reasoningConfig.enabled}, level: ${opts.reasoningLevel ?? 'default'}`,
-	);
-	debugLog(
-		`[RUNNER] final providerOptions: ${JSON.stringify(providerOptions)}`,
-	);
 
 	return {
 		cfg,

package/src/runtime/agent/runner.ts

@@ -1,12 +1,11 @@
-import { hasToolCall, stepCountIs, streamText } from 'ai';
-import { messages, messageParts, sessions } from '@ottocode/database/schema';
+import { hasToolCall, streamText } from 'ai';
+import { messageParts } from '@ottocode/database/schema';
 import { eq } from 'drizzle-orm';
 import { publish, subscribe } from '../../events/bus.ts';
-import { debugLog, time } from '../debug/index.ts';
+import { time } from '../debug/index.ts';
 import { toErrorPayload } from '../errors/handling.ts';
 import {
 	type RunOpts,
-	enqueueAssistantRun,
 	setRunning,
 	dequeueJob,
 	cleanupSession,
@@ -41,7 +40,6 @@ import {
 	createOauthCodexTextGuardState,
 	consumeOauthCodexTextDelta,
 } from '../stream/text-guard.ts';
-import { decideOauthCodexContinuation } from './oauth-codex-continuation.ts';
 import { createTurnDumpCollector } from '../debug/turn-dump.ts';
 
 export {
@@ -56,17 +54,9 @@ export {
 const DEFAULT_TRACED_TOOL_INPUTS = new Set(['write', 'apply_patch']);
 
 function shouldTraceToolInput(name: string): boolean {
-	const raw = process.env.OTTO_DEBUG_TOOL_INPUT?.trim();
-	if (!raw) return false;
-	const normalized = raw.toLowerCase();
-	if (['1', 'true', 'yes', 'on', 'all'].includes(normalized)) {
-		return DEFAULT_TRACED_TOOL_INPUTS.has(name);
-	}
-	const tokens = raw
-		.split(/[\s,]+/)
-		.map((token) => token.trim().toLowerCase())
-		.filter(Boolean);
-	return tokens.includes('all') || tokens.includes(name.toLowerCase());
+	void DEFAULT_TRACED_TOOL_INPUTS;
+	void name;
+	return false;
 }
 
 function summarizeTraceValue(value: unknown, max = 160): string {
@@ -89,11 +79,7 @@ export async function runSessionLoop(sessionId: string) {
 
 		try {
 			await runAssistant(job);
-		} catch (_err) {
-			debugLog(
-				`[RUNNER] runAssistant threw (swallowed to keep loop alive): ${_err instanceof Error ? _err.message : String(_err)}`,
-			);
-		}
+		} catch {}
 	}
 
 	setRunning(sessionId, false);
@@ -101,12 +87,6 @@ export async function runSessionLoop(sessionId: string) {
 }
 
 async function runAssistant(opts: RunOpts) {
-	const separator = '='.repeat(72);
-	debugLog(separator);
-	debugLog(
-		`[RUNNER] Starting turn for session ${opts.sessionId}, message ${opts.assistantMessageId}`,
-	);
-
 	const setup = await setupRunner(opts);
 	const {
 		cfg,
@@ -203,10 +183,6 @@ async function runAssistant(opts: RunOpts) {
 		}
 	}
 
-	debugLog(
-		`[RUNNER] messagesWithSystemInstructions length: ${messagesWithSystemInstructions.length}`,
-	);
-
 	const dump = createTurnDumpCollector({
 		sessionId: opts.sessionId,
 		messageId: opts.assistantMessageId,
@@ -282,11 +258,7 @@ async function runAssistant(opts: RunOpts) {
 			try {
 				const name = (evt.payload as { name?: string } | undefined)?.name;
 				if (name === 'finish') _finishObserved = true;
-			} catch (err) {
-				debugLog(
-					`[RUNNER] finish observer error: ${err instanceof Error ? err.message : String(err)}`,
-				);
-			}
+			} catch {}
 		}
 	});
 
@@ -364,10 +336,9 @@ async function runAssistant(opts: RunOpts) {
 	const onFinish = createFinishHandler(opts, db, completeAssistantMessage);
 	const isCopilotResponsesApi =
 		opts.provider === 'copilot' && !opts.model.startsWith('gpt-5-mini');
-	const stopWhenCondition =
-		isOpenAIOAuth || isCopilotResponsesApi
-			? stepCountIs(20)
-			: hasToolCall('finish');
+	const stopWhenCondition = isCopilotResponsesApi
+		? undefined
+		: hasToolCall('finish');
 
 	try {
 		const result = streamText({
@@ -401,29 +372,19 @@ async function runAssistant(opts: RunOpts) {
 			if (part.type === 'tool-input-start') {
 				if (shouldTraceToolInput(part.toolName)) {
 					tracedToolInputNamesById.set(part.id, part.toolName);
-					debugLog(
-						`[TOOL_INPUT_TRACE][runner] fullStream tool-input-start tool=${part.toolName} callId=${part.id}`,
-					);
 				}
 				continue;
 			}
 
 			if (part.type === 'tool-input-delta') {
 				const toolName = tracedToolInputNamesById.get(part.id);
-				if (toolName) {
-					debugLog(
-						`[TOOL_INPUT_TRACE][runner] fullStream tool-input-delta tool=${toolName} callId=${part.id} delta=${summarizeTraceValue(part.delta)}`,
-					);
-				}
+				if (toolName) void summarizeTraceValue(part.delta);
 				continue;
 			}
 
 			if (part.type === 'tool-input-end') {
 				const toolName = tracedToolInputNamesById.get(part.id);
 				if (toolName) {
-					debugLog(
-						`[TOOL_INPUT_TRACE][runner] fullStream tool-input-end tool=${toolName} callId=${part.id}`,
-					);
 					tracedToolInputNamesById.delete(part.id);
 				}
 				continue;
@@ -432,18 +393,14 @@ async function runAssistant(opts: RunOpts) {
 			if (part.type === 'tool-call') {
 				if (shouldTraceToolInput(part.toolName)) {
 					tracedToolInputNamesById.delete(part.toolCallId);
-					debugLog(
-						`[TOOL_INPUT_TRACE][runner] fullStream tool-call tool=${part.toolName} callId=${part.toolCallId} input=${summarizeTraceValue(part.input)}`,
-					);
+					void summarizeTraceValue(part.input);
 				}
 				continue;
 			}
 
 			if (part.type === 'tool-result') {
 				if (shouldTraceToolInput(part.toolName)) {
-					debugLog(
-						`[TOOL_INPUT_TRACE][runner] fullStream tool-result tool=${part.toolName} callId=${part.toolCallId} output=${summarizeTraceValue(part.output)}`,
-					);
+					void summarizeTraceValue(part.output);
 				}
 				continue;
 			}
@@ -550,11 +507,6 @@ async function runAssistant(opts: RunOpts) {
 		}
 
 		const fs = firstToolSeen();
-		if (oauthTextGuard?.dropped) {
-			debugLog(
-				'[RUNNER] Dropped pseudo tool-call text leaked by OpenAI OAuth stream',
-			);
-		}
 		if (!fs && !_finishObserved) {
 			publish({
 				type: 'finish-step',
@@ -581,10 +533,6 @@ async function runAssistant(opts: RunOpts) {
 			streamRawFinishReason = undefined;
 		}
 
-		debugLog(
-			`[RUNNER] Stream finished. finishSeen=${_finishObserved}, firstToolSeen=${fs}, trailingAssistantTextAfterTool=${_trailingAssistantTextAfterTool}, finishReason=${streamFinishReason}, rawFinishReason=${streamRawFinishReason}`,
-		);
-
 		if (dump) {
 			const finalTextSnapshot = latestAssistantText || accumulated;
 			if (finalTextSnapshot.length > 0) {
@@ -601,98 +549,6 @@ async function runAssistant(opts: RunOpts) {
 				aborted: _abortedByUser,
 			});
 		}
-
-		const MAX_CONTINUATIONS = 6;
-		const continuationCount = opts.continuationCount ?? 0;
-		const continuationDecision = decideOauthCodexContinuation({
-			provider: opts.provider,
-			isOpenAIOAuth,
-			finishObserved: _finishObserved,
-			abortedByUser: _abortedByUser,
-			continuationCount,
-			maxContinuations: MAX_CONTINUATIONS,
-			finishReason: streamFinishReason,
-			rawFinishReason: streamRawFinishReason,
-			firstToolSeen: fs,
-			hasTrailingAssistantText: _trailingAssistantTextAfterTool,
-			endedWithToolActivity: _endedWithToolActivity,
-			lastToolName: _lastToolName,
-			droppedPseudoToolText: oauthTextGuard?.dropped ?? false,
-			lastAssistantText: latestAssistantText,
-		});
-
-		if (continuationDecision.shouldContinue) {
-			const sessRows = await db
-				.select()
-				.from(sessions)
-				.where(eq(sessions.id, opts.sessionId))
-				.limit(1);
-			const sessionInputTokens = Number(sessRows[0]?.totalInputTokens ?? 0);
-			const MAX_SESSION_INPUT_TOKENS = 800_000;
-			if (sessionInputTokens > MAX_SESSION_INPUT_TOKENS) {
-				debugLog(
-					`[RUNNER] Token budget exceeded (${sessionInputTokens} > ${MAX_SESSION_INPUT_TOKENS}), stopping continuation.`,
-				);
-			} else {
-				debugLog(
-					`[RUNNER] WARNING: Stream ended without finish. reason=${continuationDecision.reason ?? 'unknown'}, finishReason=${streamFinishReason}, rawFinishReason=${streamRawFinishReason}, firstToolSeen=${fs}. Auto-continuing.`,
-				);
-
-				debugLog(
-					`[RUNNER] Auto-continuing (${continuationCount + 1}/${MAX_CONTINUATIONS})...`,
-				);
-
-				try {
-					await completeAssistantMessage({}, opts, db);
-				} catch (err) {
-					debugLog(
-						`[RUNNER] completeAssistantMessage failed before continuation: ${err instanceof Error ? err.message : String(err)}`,
-					);
-				}
-
-				const continuationMessageId = crypto.randomUUID();
-				await db.insert(messages).values({
-					id: continuationMessageId,
-					sessionId: opts.sessionId,
-					role: 'assistant',
-					status: 'pending',
-					agent: opts.agent,
-					provider: opts.provider,
-					model: opts.model,
-					createdAt: Date.now(),
-				});
-
-				publish({
-					type: 'message.created',
-					sessionId: opts.sessionId,
-					payload: {
-						id: continuationMessageId,
-						role: 'assistant',
-						agent: opts.agent,
-						provider: opts.provider,
-						model: opts.model,
-					},
-				});
-
-				enqueueAssistantRun(
-					{
-						...opts,
-						assistantMessageId: continuationMessageId,
-						continuationCount: continuationCount + 1,
-					},
-					runSessionLoop,
-				);
-				return;
-			}
-		}
-		if (
-			continuationDecision.reason === 'max-continuations-reached' &&
-			!_finishObserved
-		) {
-			debugLog(
-				`[RUNNER] Max continuations (${MAX_CONTINUATIONS}) reached, stopping.`,
-			);
-		}
 	} catch (err) {
 		unsubscribeFinish();
 		dump?.recordError(err);
@@ -715,17 +571,10 @@ async function runAssistant(opts: RunOpts) {
 			errorCode === 'context_length_exceeded' ||
 			apiErrorType === 'invalid_request_error';
 
-		debugLog(
-			`[RUNNER] isPromptTooLong: ${isPromptTooLong}, isCompactCommand: ${opts.isCompactCommand}`,
-		);
-
 		if (isPromptTooLong && !opts.isCompactCommand) {
-			debugLog('[RUNNER] Prompt too long - auto-compacting');
 			try {
 				const pruneResult = await pruneSession(db, opts.sessionId);
-				debugLog(
-					`[RUNNER] Auto-pruned ${pruneResult.pruned} parts, saved ~${pruneResult.saved} tokens`,
-				);
+				void pruneResult;
 
 				publish({
 					type: 'error',
@@ -739,20 +588,10 @@ async function runAssistant(opts: RunOpts) {
 
 				try {
 					await completeAssistantMessage({}, opts, db);
-				} catch (err2) {
-					debugLog(
-						`[RUNNER] completeAssistantMessage failed after prune: ${err2 instanceof Error ? err2.message : String(err2)}`,
-					);
-				}
+				} catch {}
 				return;
-			} catch (pruneErr) {
-				debugLog(
-					`[RUNNER] Auto-prune failed: ${pruneErr instanceof Error ? pruneErr.message : String(pruneErr)}`,
-				);
-			}
+			} catch {}
 		}
-
-		debugLog(`[RUNNER] Error during stream: ${payload.message}`);
 		publish({
 			type: 'error',
 			sessionId: opts.sessionId,
@@ -773,26 +612,13 @@ async function runAssistant(opts: RunOpts) {
 				db,
 			);
 			await completeAssistantMessage({}, opts, db);
-		} catch (err2) {
-			debugLog(
-				`[RUNNER] Failed to complete message after error: ${err2 instanceof Error ? err2.message : String(err2)}`,
-			);
-		}
+		} catch {}
 		throw err;
 	} finally {
 		if (dump) {
 			try {
-				const dumpPath = await dump.flush(cfg.projectRoot);
-				debugLog(`[RUNNER] Debug dump written to ${dumpPath}`);
-			} catch (dumpErr) {
-				debugLog(
-					`[RUNNER] Failed to write debug dump: ${dumpErr instanceof Error ? dumpErr.message : String(dumpErr)}`,
-				);
-			}
+				await dump.flush(cfg.projectRoot);
+			} catch {}
 		}
-		debugLog(
-			`[RUNNER] Turn complete for session ${opts.sessionId}, message ${opts.assistantMessageId}`,
-		);
-		debugLog(separator);
 	}
 }