@ottocode/sdk 0.1.234 → 0.1.236

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.234",
+	"version": "0.1.236",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/config/src/manager.ts

@@ -9,6 +9,9 @@ import {
 import {
 	getGlobalConfigDir,
 	getGlobalConfigPath,
+	getGlobalDebugDir,
+	getGlobalDebugLogPath,
+	getGlobalDebugSessionsDir,
 	getLocalDataDir,
 	joinPath,
 } from './paths.ts';
@@ -20,6 +23,14 @@ import {
 
 export type Scope = 'global' | 'local';
 
+export type DebugConfig = {
+	enabled: boolean;
+	scopes: string[];
+	logPath: string;
+	sessionsDir: string;
+	debugDir: string;
+};
+
 export async function read(projectRoot?: string) {
 	const cfg = await loadConfig(projectRoot);
 	const auth = await getAllAuth(projectRoot);
@@ -111,6 +122,50 @@ export async function writeDefaults(
 	await Bun.write(globalPath, JSON.stringify(next, null, 2));
 }
 
+export async function readDebugConfig(
+	projectRoot?: string,
+): Promise<DebugConfig> {
+	const cfg = await loadConfig(projectRoot);
+	return {
+		enabled: cfg.debugEnabled === true,
+		scopes: Array.isArray(cfg.debugScopes)
+			? cfg.debugScopes.filter(
+					(scope): scope is string =>
+						typeof scope === 'string' && scope.trim().length > 0,
+				)
+			: [],
+		logPath: getGlobalDebugLogPath(),
+		sessionsDir: getGlobalDebugSessionsDir(),
+		debugDir: getGlobalDebugDir(),
+	};
+}
+
+export async function writeDebugConfig(
+	updates: Partial<{
+		enabled: boolean;
+		scopes: string[];
+	}>,
+) {
+	const globalPath = getGlobalConfigPath();
+	const existing = await readJsonFile(globalPath);
+	const next: Record<string, unknown> = { ...(existing ?? {}) };
+
+	if (updates.enabled !== undefined) {
+		next.debugEnabled = updates.enabled;
+	}
+
+	if (updates.scopes !== undefined) {
+		next.debugScopes = updates.scopes;
+	}
+
+	const base = getGlobalConfigDir();
+	try {
+		const { promises: fs } = await import('node:fs');
+		await fs.mkdir(base, { recursive: true }).catch(() => {});
+	} catch {}
+	await Bun.write(globalPath, JSON.stringify(next, null, 2));
+}
+
 async function readJsonFile(
 	filePath: string,
 ): Promise<Record<string, unknown> | undefined> {

package/src/config/src/paths.ts

@@ -79,6 +79,33 @@ export function getGlobalCommandsDir(): string {
 	return joinPath(getGlobalConfigDir(), 'commands');
 }
 
+export function getGlobalDebugDir(): string {
+	return joinPath(getGlobalConfigDir(), 'debug');
+}
+
+export function getGlobalDebugLogPath(): string {
+	return joinPath(getGlobalDebugDir(), 'latest.log');
+}
+
+export function getGlobalDebugSessionsDir(): string {
+	return joinPath(getGlobalDebugDir(), 'sessions');
+}
+
+export function getSessionDebugLogPath(sessionId: string): string {
+	return joinPath(getGlobalDebugSessionsDir(), `${sessionId}.log`);
+}
+
+export function getSessionDebugDetailsLogPath(sessionId: string): string {
+	return joinPath(getGlobalDebugSessionsDir(), `${sessionId}.details.log`);
+}
+
+export function getSessionSystemPromptPath(sessionId: string): string {
+	return joinPath(
+		getGlobalDebugSessionsDir(),
+		`${sessionId}.system-prompt.txt`,
+	);
+}
+
 export function getLocalDataDir(projectRoot: string): string {
 	return joinPath(projectRoot, '.otto');
 }

package/src/core/src/terminals/manager.ts

@@ -29,14 +29,6 @@ export class TerminalManager {
 		const id = this.generateId();
 
 		try {
-			logger.debug('TerminalManager: creating terminal', {
-				id,
-				command: options.command,
-				args: options.args,
-				cwd: options.cwd,
-				purpose: options.purpose,
-			});
-
 			const ptyOptions: PtyOptions = {
 				name: 'xterm-256color',
 				cols: 80,
@@ -52,10 +44,6 @@ export class TerminalManager {
 
 			const pty = spawnPty(options.command, options.args || [], ptyOptions);
 
-			logger.debug('TerminalManager: PTY created', {
-				pid: pty.pid,
-			});
-
 			const terminal = new Terminal(id, pty, options);
 
 			terminal.onExit((_exitCode) => {
@@ -68,8 +56,6 @@ export class TerminalManager {
 
 			this.terminals.set(id, terminal);
 
-			logger.debug('TerminalManager: terminal added to map', { id });
-
 			return terminal;
 		} catch (error) {
 			logger.error('TerminalManager: failed to create terminal', error);

package/src/core/src/tools/loader.ts

@@ -179,10 +179,7 @@ export async function discoverProjectTools(
 				try {
 					const plugin = await loadPlugin(absPath, folder, projectRoot);
 					if (plugin) tools.set(plugin.name, plugin.tool);
-				} catch (err) {
-					if (process.env.OTTO_DEBUG_TOOLS === '1')
-						console.error('Failed to load tool', absPath, err);
-				}
+				} catch {}
 			}
 		}
 		// Fallback: manual directory scan

package/src/core/src/utils/debug.ts

@@ -1,40 +1,34 @@
-const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+import { readFileSync } from 'node:fs';
+import { getGlobalConfigPath } from '../../../config/src/paths.ts';
 
-type GlobalDebugFlags = {
-	__OTTO_DEBUG_ENABLED__?: boolean;
-	__OTTO_TRACE_ENABLED__?: boolean;
+type DebugSettings = {
+	debugEnabled?: boolean;
+	debugScopes?: unknown;
 };
 
-function readGlobalFlag(
-	key: '__OTTO_DEBUG_ENABLED__' | '__OTTO_TRACE_ENABLED__',
-) {
-	const globalState = globalThis as GlobalDebugFlags;
-	return globalState[key];
-}
-
-function envEnabled(keys: string[]): boolean {
-	for (const key of keys) {
-		const raw = typeof process !== 'undefined' ? process.env?.[key] : undefined;
-		if (!raw) continue;
-		const trimmed = raw.trim().toLowerCase();
-		if (!trimmed) continue;
-		if (TRUTHY.has(trimmed) || trimmed === 'all') return true;
+function readDebugSettings(): DebugSettings {
+	try {
+		const raw = readFileSync(getGlobalConfigPath(), 'utf-8');
+		const parsed = JSON.parse(raw) as DebugSettings;
+		return parsed && typeof parsed === 'object' ? parsed : {};
+	} catch {
+		return {};
 	}
-	return false;
 }
 
 export function isDebugEnabled(): boolean {
-	const globalFlag = readGlobalFlag('__OTTO_DEBUG_ENABLED__');
-	if (typeof globalFlag === 'boolean') {
-		return globalFlag;
-	}
-	return envEnabled(['OTTO_DEBUG', 'DEBUG_OTTO']);
+	return readDebugSettings().debugEnabled === true;
 }
 
 export function isTraceEnabled(): boolean {
-	const globalFlag = readGlobalFlag('__OTTO_TRACE_ENABLED__');
-	if (typeof globalFlag === 'boolean') {
-		return Boolean(globalFlag) && isDebugEnabled();
-	}
-	return envEnabled(['OTTO_TRACE', 'TRACE_OTTO']) && isDebugEnabled();
+	return false;
+}
+
+export function getDebugScopes(): string[] {
+	const scopes = readDebugSettings().debugScopes;
+	if (!Array.isArray(scopes)) return [];
+	return scopes.filter(
+		(scope): scope is string =>
+			typeof scope === 'string' && scope.trim().length > 0,
+	);
 }

package/src/core/src/utils/logger.ts

@@ -1,34 +1,165 @@
-import { isDebugEnabled, isTraceEnabled } from './debug.ts';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { isDebugEnabled, isTraceEnabled, getDebugScopes } from './debug.ts';
+import {
+	getGlobalDebugLogPath,
+	getSessionDebugDetailsLogPath,
+	getSessionDebugLogPath,
+} from '../../../config/src/paths.ts';
 
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 
+const ANSI_RESET = '\x1b[0m';
+const ANSI_DIM = '\x1b[2m';
+const ANSI_CYAN = '\x1b[36m';
+const ANSI_BLUE = '\x1b[34m';
+const ANSI_GREEN = '\x1b[32m';
+const ANSI_YELLOW = '\x1b[33m';
+const ANSI_RED = '\x1b[31m';
+
 function safeHasMeta(
 	meta?: Record<string, unknown>,
 ): meta is Record<string, unknown> {
 	return Boolean(meta && Object.keys(meta).length);
 }
 
-export function debug(message: string, meta?: Record<string, unknown>): void {
-	if (!isDebugEnabled()) return;
+function getDebugLogFilePath(): string | undefined {
+	if (!isDebugEnabled()) return undefined;
+	return getGlobalDebugLogPath();
+}
+
+function getSessionLogFilePath(
+	meta?: Record<string, unknown>,
+): string | undefined {
+	if (!isDebugEnabled()) return undefined;
+	if (meta?.debugDetail === true) return undefined;
+	const sessionId = meta?.sessionId;
+	if (typeof sessionId !== 'string' || !sessionId.trim()) return undefined;
+	return getSessionDebugLogPath(sessionId);
+}
+
+function getSessionDetailsLogFilePath(
+	meta?: Record<string, unknown>,
+): string | undefined {
+	if (!isDebugEnabled()) return undefined;
+	const sessionId = meta?.sessionId;
+	if (typeof sessionId !== 'string' || !sessionId.trim()) return undefined;
+	return getSessionDebugDetailsLogPath(sessionId);
+}
+
+function shouldWriteDebugLog(message: string): boolean {
+	if (!isDebugEnabled()) return false;
+	const scopes = getDebugScopes();
+	if (!scopes.length) return true;
+	const match = message.match(/^\[([^\]]+)\]/);
+	if (!match?.[1]) return true;
+	return scopes.includes(match[1]);
+}
+
+function serializeLogMeta(meta?: Record<string, unknown>): string {
+	if (!safeHasMeta(meta)) return '';
 	try {
-		if (safeHasMeta(meta)) {
-			console.log(`[debug] ${message}`, meta);
-		} else {
-			console.log(`[debug] ${message}`);
+		const sanitized = { ...meta };
+		delete sanitized.debugDetail;
+		return Object.keys(sanitized).length ? ` ${JSON.stringify(sanitized)}` : '';
+	} catch {
+		return ' [unserializable-meta]';
+	}
+}
+
+function colorizeLine(line: string, level: LogLevel): string {
+	const levelColor =
+		level === 'debug'
+			? ANSI_CYAN
+			: level === 'info'
+				? ANSI_BLUE
+				: level === 'warn'
+					? ANSI_YELLOW
+					: ANSI_RED;
+	const scopeMatch = line.match(
+		/\[(debug|info|warn|error|timing)\]\s+\[([^\]]+)\]/i,
+	);
+	if (!scopeMatch) {
+		return `${levelColor}${line}${ANSI_RESET}`;
+	}
+	const rest = line.slice(24);
+	return `${ANSI_DIM}${line.slice(0, 24)}${ANSI_RESET}${rest
+		.replace(scopeMatch[1], `${levelColor}${scopeMatch[1]}${ANSI_RESET}`)
+		.replace(
+			`[${scopeMatch[2]}]`,
+			`${ANSI_GREEN}[${scopeMatch[2]}]${ANSI_RESET}`,
+		)}`;
+}
+
+function printLine(
+	level: LogLevel,
+	line: string,
+	meta?: Record<string, unknown>,
+) {
+	const colored = colorizeLine(line, level);
+	if (safeHasMeta(meta)) {
+		if (level === 'warn') console.warn(colored, meta);
+		else if (level === 'error') console.error(colored, meta);
+		else console.log(colored, meta);
+		return;
+	}
+	if (level === 'warn') console.warn(colored);
+	else if (level === 'error') console.error(colored);
+	else console.log(colored);
+}
+
+function writeLogLine(line: string, meta?: Record<string, unknown>) {
+	const suffix = serializeLogMeta(meta);
+	const fullLine = `${new Date().toISOString()} ${line}${suffix}`;
+	const logFile = getDebugLogFilePath();
+
+	if (logFile) {
+		try {
+			mkdirSync(dirname(logFile), { recursive: true });
+			appendFileSync(logFile, `${fullLine}\n`, 'utf-8');
+		} catch {
+			// ignore file logging errors
+		}
+	}
+
+	const sessionLogFile = getSessionLogFilePath(meta);
+	if (sessionLogFile) {
+		try {
+			mkdirSync(dirname(sessionLogFile), { recursive: true });
+			appendFileSync(sessionLogFile, `${fullLine}\n`, 'utf-8');
+		} catch {
+			// ignore file logging errors
+		}
+	}
+
+	const sessionDetailsLogFile = getSessionDetailsLogFilePath(meta);
+	if (sessionDetailsLogFile) {
+		try {
+			mkdirSync(dirname(sessionDetailsLogFile), { recursive: true });
+			appendFileSync(sessionDetailsLogFile, `${fullLine}\n`, 'utf-8');
+		} catch {
+			// ignore file logging errors
 		}
+	}
+
+	return fullLine;
+}
+
+export function debug(message: string, meta?: Record<string, unknown>): void {
+	if (!shouldWriteDebugLog(message)) return;
+	try {
+		const line = writeLogLine(`[debug] ${message}`, meta);
+		printLine('debug', line, meta);
 	} catch {
 		// ignore logging errors
 	}
 }
 
 export function info(message: string, meta?: Record<string, unknown>): void {
-	if (!isDebugEnabled() && !isTraceEnabled()) return;
+	if (!shouldWriteDebugLog(message) && !isTraceEnabled()) return;
 	try {
-		if (safeHasMeta(meta)) {
-			console.log(`[info] ${message}`, meta);
-		} else {
-			console.log(`[info] ${message}`);
-		}
+		const line = writeLogLine(`[info] ${message}`, meta);
+		printLine('info', line, meta);
 	} catch {
 		// ignore logging errors
 	}
@@ -36,11 +167,8 @@ export function info(message: string, meta?: Record<string, unknown>): void {
 
 export function warn(message: string, meta?: Record<string, unknown>): void {
 	try {
-		if (safeHasMeta(meta)) {
-			console.warn(`[warn] ${message}`, meta);
-		} else {
-			console.warn(`[warn] ${message}`);
-		}
+		const line = writeLogLine(`[warn] ${message}`, meta);
+		printLine('warn', line, meta);
 	} catch {
 		// ignore logging errors
 	}
@@ -91,9 +219,11 @@ export function error(
 		}
 
 		if (safeHasMeta(logMeta)) {
-			console.error(`[error] ${message}`, logMeta);
+			const line = writeLogLine(`[error] ${message}`, logMeta);
+			printLine('error', line, logMeta);
 		} else {
-			console.error(`[error] ${message}`);
+			const line = writeLogLine(`[error] ${message}`);
+			printLine('error', line);
 		}
 	} catch (logErr) {
 		try {
@@ -136,12 +266,11 @@ export function time(label: string): Timer {
 			finished = true;
 			const duration = nowMs() - start;
 			try {
-				const base = `[timing] ${label} ${duration.toFixed(1)}ms`;
-				if (safeHasMeta(meta)) {
-					console.log(base, meta);
-				} else {
-					console.log(base);
-				}
+				const base = writeLogLine(
+					`[timing] ${label} ${duration.toFixed(1)}ms`,
+					meta,
+				);
+				printLine('info', base, meta);
 			} catch {
 				// ignore timing log errors
 			}

package/src/index.ts

@@ -177,6 +177,12 @@ export {
 	getGlobalAgentsDir,
 	getGlobalToolsDir,
 	getGlobalCommandsDir,
+	getGlobalDebugDir,
+	getGlobalDebugLogPath,
+	getGlobalDebugSessionsDir,
+	getSessionDebugLogPath,
+	getSessionDebugDetailsLogPath,
+	getSessionSystemPromptPath,
 	getSecureAuthPath,
 	getSecureBaseDir,
 	getSecureOAuthDir,
@@ -187,12 +193,14 @@ export {
 	isAuthorized,
 	ensureEnv,
 	writeDefaults as setConfig,
+	readDebugConfig,
+	writeDebugConfig,
 	writeAuth,
 	removeAuth as removeConfig,
 	getOnboardingComplete,
 	setOnboardingComplete,
 } from './config/src/manager.ts';
-export type { Scope } from './config/src/manager.ts';
+export type { Scope, DebugConfig } from './config/src/manager.ts';
 
 // =======================
 // Prompts (from internal prompts module)

package/src/prompts/src/base.txt

@@ -3,6 +3,12 @@ You are a helpful, concise assistant.
 - Do not print pseudo tool calls like `call:tool{}`; invoke tools directly.
 - Use sensible default filenames when needed.
 - Prefer minimal, precise outputs and actionable steps.
+- Keep user-facing responses short, scannable, and suitable for a terminal UI.
+- Default to a concise teammate tone unless the user explicitly asks for detail.
+- Avoid long retrospective narratives of every step you took.
+- Do not restate tool outputs unless they are necessary for the user.
+- Final responses should usually be 3-6 short bullets or a few short paragraphs.
+- Focus on outcome, key files, verification, and only the most relevant next step.
 
 ## Finish Tool - CRITICAL
 

package/src/prompts/src/debug.ts

@@ -1,104 +1,15 @@
-const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
-
-const SYNONYMS: Record<string, string> = {
-	debug: 'log',
-	logs: 'log',
-	logging: 'log',
-	trace: 'log',
-	verbose: 'log',
-	log: 'log',
-	time: 'timing',
-	timing: 'timing',
-	timings: 'timing',
-	perf: 'timing',
-};
-
-type DebugConfig = { flags: Set<string> };
-
-let cachedConfig: DebugConfig | null = null;
-
-function isTruthy(raw: string | undefined): boolean {
-	if (!raw) return false;
-	const trimmed = raw.trim().toLowerCase();
-	if (!trimmed) return false;
-	return TRUTHY.has(trimmed) || trimmed === 'all';
-}
-
-function normalizeToken(token: string): string {
-	const trimmed = token.trim().toLowerCase();
-	if (!trimmed) return '';
-	if (TRUTHY.has(trimmed) || trimmed === 'all') return 'all';
-	return SYNONYMS[trimmed] ?? trimmed;
-}
-
-function parseDebugConfig(): DebugConfig {
-	const flags = new Set<string>();
-	const sources = [process.env.OTTO_DEBUG, process.env.DEBUG_OTTO];
-	let sawValue = false;
-	for (const raw of sources) {
-		if (typeof raw !== 'string') continue;
-		const trimmed = raw.trim();
-		if (!trimmed) continue;
-		sawValue = true;
-		const tokens = trimmed.split(/[\s,]+/);
-		let matched = false;
-		for (const token of tokens) {
-			const normalized = normalizeToken(token);
-			if (!normalized) continue;
-			matched = true;
-			flags.add(normalized);
-		}
-		if (!matched && isTruthy(trimmed)) flags.add('all');
-	}
-	if (isTruthy(process.env.OTTO_DEBUG_TIMING)) flags.add('timing');
-	if (!flags.size && sawValue) flags.add('all');
-	return { flags };
-}
-
-function getDebugConfig(): DebugConfig {
-	if (!cachedConfig) cachedConfig = parseDebugConfig();
-	return cachedConfig;
-}
-
 export function isDebugEnabled(flag?: string): boolean {
-	const config = getDebugConfig();
-	if (config.flags.has('all')) return true;
-	if (flag) return config.flags.has(flag);
-	return config.flags.has('log');
-}
-
-export function debugLog(...args: unknown[]) {
-	if (!isDebugEnabled('log')) return;
-	try {
-		console.log('[debug]', ...args);
-	} catch {}
-}
-
-function nowMs(): number {
-	const perf = (globalThis as { performance?: { now?: () => number } })
-		.performance;
-	if (perf && typeof perf.now === 'function') return perf.now();
-	return Date.now();
+	void flag;
+	return false;
 }
 
 type Timer = { end(meta?: Record<string, unknown>): void };
 
 export function time(label: string): Timer {
-	if (!isDebugEnabled('timing')) {
-		return { end() {} };
-	}
-	const start = nowMs();
-	let finished = false;
+	void label;
 	return {
 		end(meta?: Record<string, unknown>) {
-			if (finished) return;
-			finished = true;
-			const duration = nowMs() - start;
-			try {
-				const line = `[timing] ${label} ${duration.toFixed(1)}ms`;
-				if (meta && Object.keys(meta).length) console.log(line, meta);
-				else console.log(line);
-			} catch {}
+			void meta;
 		},
 	};
 }

package/src/prompts/src/providers.ts

@@ -1,4 +1,3 @@
-import { debugLog } from './debug.ts';
 import {
 	getModelFamily,
 	getModelInfo,
@@ -91,9 +90,6 @@ export async function providerBasePrompt(
 			const modelText = await readIfExists(modelPath);
 			if (!modelText) continue;
 			const promptType = `model:${sanitized}`;
-			debugLog(
-				`[provider] prompt: ${promptType} (${modelText.length} chars) from ${modelPath}`,
-			);
 			return { prompt: modelText, resolvedType: promptType };
 		}
 	}
@@ -101,9 +97,6 @@ export async function providerBasePrompt(
 	for (const providerPath of providerPaths) {
 		const providerText = await readIfExists(providerPath);
 		if (!providerText) continue;
-		debugLog(
-			`[provider] prompt: custom:${id} (${providerText.length} chars) from ${providerPath}`,
-		);
 		return { prompt: providerText, resolvedType: `custom:${id}` };
 	}
 
@@ -112,49 +105,37 @@ export async function providerBasePrompt(
 		if (info?.ownedBy) {
 			const family = getModelFamily(id, modelId);
 			const result = promptForFamily(family);
-			debugLog(
-				`[provider] prompt: ownedBy:${info.ownedBy} (via ${id}/${modelId}, ${result.length} chars)`,
-			);
 			return { prompt: result, resolvedType: family ?? info.ownedBy };
 		}
 
 		const family = getModelFamily(id, modelId);
 		if (family) {
 			const result = promptForFamily(family);
-			debugLog(
-				`[provider] prompt: family:${family} (via ${id}/${modelId}, ${result.length} chars)`,
-			);
 			return { prompt: result, resolvedType: family };
 		}
 	}
 
 	if (id === 'openai') {
 		const result = PROVIDER_OPENAI.trim();
-		debugLog(`[provider] prompt: openai (${result.length} chars)`);
 		return { prompt: result, resolvedType: 'openai' };
 	}
 	if (id === 'anthropic') {
 		const result = PROVIDER_ANTHROPIC.trim();
-		debugLog(`[provider] prompt: anthropic (${result.length} chars)`);
 		return { prompt: result, resolvedType: 'anthropic' };
 	}
 	if (id === 'google') {
 		const result = PROVIDER_GOOGLE.trim();
-		debugLog(`[provider] prompt: google (${result.length} chars)`);
 		return { prompt: result, resolvedType: 'google' };
 	}
 	if (id === 'moonshot') {
 		const result = PROVIDER_MOONSHOT.trim();
-		debugLog(`[provider] prompt: moonshot (${result.length} chars)`);
 		return { prompt: result, resolvedType: 'moonshot' };
 	}
 	if (id === 'zai' || id === 'zai-coding') {
 		const result = PROVIDER_GLM.trim();
-		debugLog(`[provider] prompt: glm (${result.length} chars)`);
 		return { prompt: result, resolvedType: 'glm' };
 	}
 
 	const result = PROVIDER_DEFAULT.trim();
-	debugLog(`[provider] prompt: default (${result.length} chars)`);
 	return { prompt: result, resolvedType: 'default' };
 }

package/src/providers/src/openai-oauth-client.ts

@@ -2,6 +2,10 @@ import { createOpenAI } from '@ai-sdk/openai';
 import type { OAuth } from '../../types/src/index.ts';
 import { refreshOpenAIToken } from '../../auth/src/openai-oauth.ts';
 import { setAuth, getAuth } from '../../auth/src/index.ts';
+import {
+	debug as loggerDebug,
+	warn as loggerWarn,
+} from '../../core/src/utils/logger.ts';
 import os from 'node:os';
 
 const CODEX_BASE_URL = 'https://chatgpt.com/backend-api/codex';
@@ -11,12 +15,48 @@ const TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1000;
 const TOKEN_REFRESH_MAX_RETRIES = 2;
 const TOKEN_REFRESH_RETRY_DELAY_MS = 1000;
 
+type OpenAIOAuthSessionState = {
+	responseId?: string;
+	model?: string;
+	status?: string;
+	incompleteReason?: string;
+};
+
+const openAIOAuthSessionState = new Map<string, OpenAIOAuthSessionState>();
+
 export type OpenAIOAuthConfig = {
 	oauth: OAuth;
 	projectRoot?: string;
 	sessionId?: string;
 };
 
+function shouldDebugOpenAIOAuth() {
+	return false;
+}
+
+function logOpenAIOAuth(message: string) {
+	if (shouldDebugOpenAIOAuth()) {
+		loggerDebug(`[openai-oauth] ${message}`);
+	}
+}
+
+function shouldUsePreviousResponseId() {
+	return process.env.OTTO_OPENAI_OAUTH_PREVIOUS_RESPONSE_ID === '1';
+}
+
+export function clearOpenAIOAuthSessionState(sessionId?: string) {
+	if (sessionId) {
+		openAIOAuthSessionState.delete(sessionId);
+		return;
+	}
+	openAIOAuthSessionState.clear();
+}
+
+export function getOpenAIOAuthSessionState(sessionId: string) {
+	const state = openAIOAuthSessionState.get(sessionId);
+	return state ? { ...state } : undefined;
+}
+
 function sleep(ms: number) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -65,7 +105,7 @@ async function ensureValidToken(
 			accountId: updated.accountId,
 		};
 	} catch {
-		console.error(
+		loggerWarn(
 			'[openai-oauth] Token refresh failed after retries, falling back to current token',
 		);
 		return { oauth, access: oauth.access, accountId: oauth.accountId };
@@ -83,6 +123,187 @@ function rewriteUrl(url: string): string {
 	return url;
 }
 
+function readSessionState(sessionId?: string) {
+	if (!sessionId) return undefined;
+	return openAIOAuthSessionState.get(sessionId);
+}
+
+function writeSessionState(sessionId: string, next: OpenAIOAuthSessionState) {
+	openAIOAuthSessionState.set(sessionId, next);
+}
+
+function rewriteRequestBody(
+	body: string,
+	sessionId?: string,
+): { body: string; previousResponseId?: string; model?: string } {
+	try {
+		const parsed = JSON.parse(body) as Record<string, unknown>;
+		const model = typeof parsed.model === 'string' ? parsed.model : undefined;
+		if (!sessionId) {
+			return { body, model };
+		}
+
+		const prior = readSessionState(sessionId);
+		if (
+			prior?.responseId &&
+			!parsed.previous_response_id &&
+			(!prior.model || !model || prior.model === model)
+		) {
+			if (!shouldUsePreviousResponseId()) {
+				logOpenAIOAuth(
+					`not injecting previous_response_id=${prior.responseId} for session=${sessionId} model=${model ?? 'unknown'} because Codex HTTP backend rejects it; enable OTTO_OPENAI_OAUTH_PREVIOUS_RESPONSE_ID=1 only for validation`,
+				);
+				return { body, model };
+			}
+			parsed.previous_response_id = prior.responseId;
+			logOpenAIOAuth(
+				`injecting previous_response_id=${prior.responseId} for session=${sessionId} model=${model ?? 'unknown'}`,
+			);
+			return {
+				body: JSON.stringify(parsed),
+				previousResponseId: prior.responseId,
+				model,
+			};
+		}
+
+		return { body, model };
+	} catch {
+		return { body };
+	}
+}
+
+function previewText(value: unknown, maxLength = 240): string | undefined {
+	if (typeof value !== 'string') return undefined;
+	const normalized = value.replace(/\s+/g, ' ').trim();
+	if (!normalized) return undefined;
+	return normalized.length > maxLength
+		? `${normalized.slice(0, maxLength)}…`
+		: normalized;
+}
+
+function summarizeRequestBody(body: string): string {
+	try {
+		const parsed = JSON.parse(body) as Record<string, unknown>;
+		const input = Array.isArray(parsed.input) ? parsed.input : [];
+		const systemMessages = input.filter((item) => {
+			if (!item || typeof item !== 'object') return false;
+			const role = (item as Record<string, unknown>).role;
+			return role === 'system';
+		});
+		const systemPreview = previewText(
+			(systemMessages[0] as Record<string, unknown> | undefined)?.content,
+		);
+		const instructionsPreview = previewText(parsed.instructions);
+		return [
+			`model=${typeof parsed.model === 'string' ? parsed.model : 'unknown'}`,
+			`instructionsPresent=${typeof parsed.instructions === 'string'}`,
+			`instructionsPreview=${instructionsPreview ?? 'none'}`,
+			`inputCount=${input.length}`,
+			`systemMessageCount=${systemMessages.length}`,
+			`firstSystemPreview=${systemPreview ?? 'none'}`,
+			`previousResponseId=${typeof parsed.previous_response_id === 'string' ? parsed.previous_response_id : 'none'}`,
+		].join(' ');
+	} catch {
+		return 'unparseable-body';
+	}
+}
+
+function trackResponseEvent(data: string, sessionId?: string) {
+	if (!sessionId) return;
+
+	try {
+		const parsed = JSON.parse(data) as Record<string, unknown>;
+		const type = typeof parsed.type === 'string' ? parsed.type : undefined;
+		const response =
+			parsed.response && typeof parsed.response === 'object'
+				? (parsed.response as Record<string, unknown>)
+				: undefined;
+		const responseId =
+			typeof response?.id === 'string'
+				? response.id
+				: typeof parsed.response_id === 'string'
+					? parsed.response_id
+					: undefined;
+		const responseModel =
+			typeof response?.model === 'string' ? response.model : undefined;
+		const responseStatus =
+			typeof response?.status === 'string' ? response.status : undefined;
+		const incompleteReason =
+			response?.incomplete_details &&
+			typeof response.incomplete_details === 'object' &&
+			typeof (response.incomplete_details as Record<string, unknown>).reason ===
+				'string'
+				? ((response.incomplete_details as Record<string, unknown>)
+						.reason as string)
+				: undefined;
+
+		if (responseId) {
+			const prior = readSessionState(sessionId);
+			writeSessionState(sessionId, {
+				responseId,
+				model: responseModel ?? prior?.model,
+				status: responseStatus ?? type,
+				incompleteReason,
+			});
+			logOpenAIOAuth(
+				`tracked response event type=${type ?? 'unknown'} responseId=${responseId} session=${sessionId} status=${responseStatus ?? 'unknown'} incompleteReason=${incompleteReason ?? 'none'}`,
+			);
+		}
+	} catch {
+		// ignore non-JSON data chunks
+	}
+}
+
+function trackResponsesStream(
+	response: Response,
+	sessionId?: string,
+): Response {
+	if (!response.body || !sessionId) {
+		return response;
+	}
+
+	const decoder = new TextDecoder();
+	const encoder = new TextEncoder();
+	let buffer = '';
+
+	const transform = new TransformStream<Uint8Array, Uint8Array>({
+		transform(chunk, controller) {
+			buffer += decoder.decode(chunk, { stream: true }).replace(/\r\n/g, '\n');
+			let boundary = buffer.indexOf('\n\n');
+			while (boundary !== -1) {
+				const rawEvent = buffer.slice(0, boundary);
+				buffer = buffer.slice(boundary + 2);
+
+				const dataLines: string[] = [];
+				for (const line of rawEvent.split('\n')) {
+					if (line.startsWith('data:')) {
+						dataLines.push(line.slice('data:'.length).trimStart());
+					}
+				}
+				const data = dataLines.join('\n');
+				if (data && data !== '[DONE]') {
+					trackResponseEvent(data, sessionId);
+				}
+
+				controller.enqueue(encoder.encode(`${rawEvent}\n\n`));
+				boundary = buffer.indexOf('\n\n');
+			}
+		},
+		flush(controller) {
+			buffer += decoder.decode().replace(/\r\n/g, '\n');
+			if (buffer.length > 0) {
+				controller.enqueue(encoder.encode(buffer));
+			}
+		},
+	});
+
+	return new Response(response.body.pipeThrough(transform), {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers,
+	});
+}
+
 function buildHeaders(
 	init: RequestInit | undefined,
 	accessToken: string,
@@ -124,20 +345,44 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 					? input.href
 					: input.url;
 		const targetUrl = rewriteUrl(originalUrl);
+		const isResponsesRequest = targetUrl === CODEX_RESPONSES_URL;
+		let requestInit = init;
+		let requestModel: string | undefined;
+		if (isResponsesRequest && typeof init?.body === 'string') {
+			const rewritten = rewriteRequestBody(init.body, config.sessionId);
+			requestModel = rewritten.model;
+			requestInit =
+				rewritten.body !== init.body ? { ...init, body: rewritten.body } : init;
+			logOpenAIOAuth(
+				`request payload summary: ${summarizeRequestBody(requestInit?.body && typeof requestInit.body === 'string' ? requestInit.body : init.body)}`,
+			);
+			if (config.sessionId && requestModel) {
+				const prior = readSessionState(config.sessionId);
+				writeSessionState(config.sessionId, {
+					responseId: prior?.responseId,
+					model: requestModel,
+					status: prior?.status,
+					incompleteReason: prior?.incompleteReason,
+				});
+			}
+		}
 
 		const headers = buildHeaders(
-			init,
+			requestInit,
 			validated.access,
 			validated.accountId,
 			config.sessionId,
 		);
 
 		const response = await fetch(targetUrl, {
-			...init,
+			...requestInit,
 			headers,
 			// @ts-expect-error Bun-specific fetch option
 			timeout: false,
 		});
+		const trackedResponse = isResponsesRequest
+			? trackResponsesStream(response, config.sessionId)
+			: response;
 
 		if (response.status === 401) {
 			try {
@@ -155,18 +400,21 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 				}
 
 				const retryHeaders = buildHeaders(
-					init,
+					requestInit,
 					currentOAuth.access,
 					currentOAuth.accountId,
 					config.sessionId,
 				);
 
-				return fetch(targetUrl, {
-					...init,
+				const retryResponse = await fetch(targetUrl, {
+					...requestInit,
 					headers: retryHeaders,
 					// @ts-expect-error Bun-specific fetch option
 					timeout: false,
 				});
+				return isResponsesRequest
+					? trackResponsesStream(retryResponse, config.sessionId)
+					: retryResponse;
 			} catch {
 				console.error(
 					'[openai-oauth] 401 retry failed, returning original 401 response',
@@ -175,7 +423,7 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 			}
 		}
 
-		return response;
+		return trackedResponse;
 	};
 
 	return customFetch as typeof fetch;

package/src/skills/loader.ts

@@ -198,20 +198,10 @@ async function loadSkillsFromDir(
 			const skill = parseSkillFile(content, filePath, scope);
 
 			const dirName = dirname(filePath).split(/[\\/]/).pop();
-			if (dirName !== skill.metadata.name) {
-				if (process.env.OTTO_DEBUG === '1') {
-					console.warn(
-						`Skill name '${skill.metadata.name}' doesn't match directory '${dirName}' in ${filePath}`,
-					);
-				}
-			}
+			void dirName;
 
 			skills.set(skill.metadata.name, skill);
-		} catch (err) {
-			if (process.env.OTTO_DEBUG === '1') {
-				console.error(`Failed to load skill from ${filePath}:`, err);
-			}
-		}
+		} catch {}
 	}
 }
 

package/src/types/src/config.ts

@@ -55,5 +55,7 @@ export type OttoConfig = {
 	defaults: DefaultConfig;
 	providers: ProviderSettings;
 	paths: PathConfig;
+	debugEnabled?: boolean;
+	debugScopes?: string[];
 	onboardingComplete?: boolean;
 };