@ottocode/sdk 0.1.313 → 0.1.314

package/package.json

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

package/src/config/src/index.ts

@@ -1,7 +1,10 @@
 import {
+	getProjectConfigDir,
+	getProjectConfigPath,
+	getProjectStateDir,
+	getLegacyProjectDataDir,
 	getGlobalConfigPath,
 	getGlobalSkillsConfigPath,
-	getLocalDataDir,
 	ensureDir,
 	fileExists,
 	joinPath,
@@ -46,6 +49,7 @@ const DEFAULTS: {
 		releaseToSend: false,
 		fullWidthContent: false,
 		autoCompactThresholdTokens: null,
+		coAuthorCommits: false,
 		ottoEnabled: true,
 	},
 	providers: DEFAULT_PROVIDER_SETTINGS,
@@ -64,9 +68,21 @@ export async function loadConfig(
 		? String(projectRootInput)
 		: process.cwd();
 
-	const dataDir = getLocalDataDir(projectRoot);
-	const dbPath = joinPath(dataDir, 'otto.sqlite');
-	const projectConfigPath = joinPath(dataDir, 'config.json');
+	const projectConfigDir = getProjectConfigDir(projectRoot);
+	const projectConfigPath = getProjectConfigPath(projectRoot);
+	const projectStateDir = await getProjectStateDir(projectRoot);
+	const dataDir = projectStateDir;
+	const dbPath = joinPath(projectStateDir, 'otto.sqlite');
+	const attachmentsDir = joinPath(projectStateDir, 'attachments');
+	const debugDir = joinPath(projectStateDir, 'debug');
+	const debugDumpsDir = joinPath(projectStateDir, 'debug-dumps');
+	const logsDir = joinPath(projectStateDir, 'logs');
+	const tmpDir = joinPath(projectStateDir, 'tmp');
+	const cacheDir = joinPath(projectStateDir, 'cache');
+	const legacyDbPath = joinPath(
+		getLegacyProjectDataDir(projectRoot),
+		'otto.sqlite',
+	);
 	const globalConfigPath = getGlobalConfigPath();
 	const globalSkillsConfigPath = getGlobalSkillsConfigPath();
 
@@ -81,7 +97,12 @@ export async function loadConfig(
 		filterProjectConfig(projectCfg),
 	);
 
-	await ensureDir(dataDir);
+	await ensureDir(projectStateDir);
+	if ((await fileExists(legacyDbPath)) && !(await fileExists(dbPath))) {
+		console.warn(
+			`Legacy Otto database found at ${legacyDbPath}. Run: otto storage migrate`,
+		);
+	}
 
 	return {
 		projectRoot,
@@ -89,11 +110,19 @@ export async function loadConfig(
 		providers: merged.providers as OttoConfig['providers'],
 		skills: merged.skills as OttoConfig['skills'],
 		paths: {
-			dataDir,
-			dbPath,
+			projectConfigDir,
 			projectConfigPath: (await fileExists(projectConfigPath))
 				? projectConfigPath
 				: null,
+			projectStateDir,
+			dataDir,
+			dbPath,
+			attachmentsDir,
+			debugDir,
+			debugDumpsDir,
+			logsDir,
+			tmpDir,
+			cacheDir,
 			globalConfigPath: (await fileExists(globalConfigPath))
 				? globalConfigPath
 				: null,

package/src/config/src/manager.ts

@@ -93,6 +93,7 @@ export async function writeDefaults(
 		releaseToSend: boolean;
 		fullWidthContent: boolean;
 		autoCompactThresholdTokens: number | null;
+		coAuthorCommits: boolean;
 		ottoEnabled: boolean;
 	}>,
 	projectRoot?: string,

package/src/config/src/paths.ts

@@ -110,18 +110,236 @@ export function getSessionSystemPromptPath(sessionId: string): string {
 	);
 }
 
-export function getLocalDataDir(projectRoot: string): string {
+/** Resolve the user-level Otto home directory for project state storage. */
+export function getOttoHomeDir(): string {
+	const ottoHome = process.env.OTTO_HOME;
+	if (ottoHome?.trim()) return ottoHome.replace(/\\/g, '/');
+	if (process.platform === 'win32') {
+		const appData = (process.env.APPDATA || '').replace(/\\/g, '/');
+		const base = appData || joinPath(getHomeDir(), 'AppData', 'Roaming');
+		return joinPath(base, 'otto');
+	}
+	return joinPath(getHomeDir(), '.local', 'state', 'otto');
+}
+
+/** Resolve the root directory containing per-project state directories. */
+export function getProjectsStateRoot(): string {
+	return joinPath(getOttoHomeDir(), 'projects');
+}
+
+const projectIdCache = new Map<string, Promise<string>>();
+
+/** Build a stable readable project ID from basename and git remote/path hash. */
+export async function getProjectId(projectRoot: string): Promise<string> {
+	const normalizedProjectRoot = projectRoot.replace(/\\/g, '/');
+	const cached = projectIdCache.get(normalizedProjectRoot);
+	if (cached) return cached;
+
+	const projectId = resolveProjectId(normalizedProjectRoot);
+	projectIdCache.set(normalizedProjectRoot, projectId);
+	return projectId;
+}
+
+async function resolveProjectId(
+	normalizedProjectRoot: string,
+): Promise<string> {
+	const slug = sanitizeProjectSlug(getPathBasename(normalizedProjectRoot));
+	const hashInput =
+		(await readGitRemoteUrl(normalizedProjectRoot)) ??
+		(await getCanonicalProjectRoot(normalizedProjectRoot));
+	const hash = (await sha256Hex(hashInput)).slice(0, 8);
+	return `${slug}-${hash}`;
+}
+
+/** Resolve the repository-local Otto project config directory. */
+export function getProjectConfigDir(projectRoot: string): string {
 	return joinPath(projectRoot, '.otto');
 }
 
+/** Resolve the repository-local Otto project config file path. */
+export function getProjectConfigPath(projectRoot: string): string {
+	return joinPath(getProjectConfigDir(projectRoot), 'config.json');
+}
+
+/** Resolve the user-level state directory for a project. */
+export async function getProjectStateDir(projectRoot: string): Promise<string> {
+	return joinPath(getProjectsStateRoot(), await getProjectId(projectRoot));
+}
+
+/** Resolve the project SQLite database path under user-level state. */
+export async function getProjectDbPath(projectRoot: string): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'otto.sqlite');
+}
+
+/** Resolve the project attachments directory under user-level state. */
+export async function getProjectAttachmentsDir(
+	projectRoot: string,
+): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'attachments');
+}
+
+/** Resolve the project debug directory under user-level state. */
+export async function getProjectDebugDir(projectRoot: string): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'debug');
+}
+
+/** Resolve the project debug dumps directory under user-level state. */
+export async function getProjectDebugDumpsDir(
+	projectRoot: string,
+): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'debug-dumps');
+}
+
+/** Resolve the project logs directory under user-level state. */
+export async function getProjectLogsDir(projectRoot: string): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'logs');
+}
+
+/** Resolve the project temporary files directory under user-level state. */
+export async function getProjectTmpDir(projectRoot: string): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'tmp');
+}
+
+/** Resolve the project cache directory under user-level state. */
+export async function getProjectCacheDir(projectRoot: string): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'cache');
+}
+
+/** Resolve the legacy repository-local data directory used before migration. */
+export function getLegacyProjectDataDir(projectRoot: string): string {
+	return joinPath(projectRoot, '.otto');
+}
+
+/** @deprecated Use getLegacyProjectDataDir() for legacy project-local data. */
+export function getLocalDataDir(projectRoot: string): string {
+	return getLegacyProjectDataDir(projectRoot);
+}
+
+function sanitizeProjectSlug(name: string): string {
+	return name.replace(/[^a-zA-Z0-9._-]+/g, '-') || 'project';
+}
+
+function getPathBasename(path: string): string {
+	const trimmed = path.replace(/\/+$/g, '');
+	const index = trimmed.lastIndexOf('/');
+	return index >= 0 ? trimmed.slice(index + 1) : trimmed;
+}
+
+async function sha256Hex(input: string): Promise<string> {
+	const subtle = globalThis.crypto?.subtle;
+	if (subtle) {
+		const encoded = new TextEncoder().encode(input);
+		const digest = await subtle.digest('SHA-256', encoded);
+		return Array.from(new Uint8Array(digest), (byte) =>
+			byte.toString(16).padStart(2, '0'),
+		).join('');
+	}
+
+	const { createHash } = await loadCrypto();
+	return createHash('sha256').update(input).digest('hex');
+}
+
+async function getCanonicalProjectRoot(projectRoot: string): Promise<string> {
+	try {
+		const { realpath } = await loadFsPromises();
+		return (await realpath(projectRoot)).replace(/\\/g, '/');
+	} catch {
+		return projectRoot.replace(/\\/g, '/');
+	}
+}
+
+async function readGitRemoteUrl(
+	projectRoot: string,
+): Promise<string | undefined> {
+	const currentBranchRemote = await readCurrentBranchRemote(projectRoot);
+	const remoteNames = currentBranchRemote
+		? [currentBranchRemote, 'origin']
+		: ['origin'];
+
+	for (const remoteName of remoteNames) {
+		const remoteUrl = await readGitConfigValue(
+			projectRoot,
+			`remote.${remoteName}.url`,
+		);
+		if (remoteUrl) return remoteUrl;
+	}
+
+	const remoteList = await readGitConfigValues(
+		projectRoot,
+		'config',
+		'--get-regexp',
+		'remote\\..*\\.url',
+	);
+	return remoteList
+		.map((line) => line.trim().split(/\s+/, 2)[1])
+		.find((url) => url?.trim());
+}
+
+async function readCurrentBranchRemote(
+	projectRoot: string,
+): Promise<string | undefined> {
+	const branch = await readGitConfigValues(
+		projectRoot,
+		'rev-parse',
+		'--abbrev-ref',
+		'HEAD',
+	);
+	const branchName = branch[0];
+	if (!branchName || branchName === 'HEAD') return undefined;
+	return readGitConfigValue(projectRoot, `branch.${branchName}.remote`);
+}
+
+async function readGitConfigValue(
+	projectRoot: string,
+	key: string,
+): Promise<string | undefined> {
+	const values = await readGitConfigValues(projectRoot, 'config', '--get', key);
+	return values[0];
+}
+
+async function readGitConfigValues(
+	projectRoot: string,
+	...args: string[]
+): Promise<string[]> {
+	try {
+		const { execFile } = await loadChildProcess();
+		const { promisify } = await loadUtil();
+		const execFileAsync = promisify(execFile);
+		const { stdout } = await execFileAsync('git', ['-C', projectRoot, ...args]);
+		const output = String(stdout);
+		return output
+			.split('\n')
+			.map((line) => line.trim())
+			.filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+
 async function loadFsPromises(): Promise<typeof import('node:fs/promises')> {
 	return Function('specifier', 'return import(specifier)')('node:fs/promises');
 }
 
+async function loadChildProcess(): Promise<
+	typeof import('node:child_process')
+> {
+	return Function(
+		'specifier',
+		'return import(specifier)',
+	)('node:child_process');
+}
+
+async function loadUtil(): Promise<typeof import('node:util')> {
+	return Function('specifier', 'return import(specifier)')('node:util');
+}
+
+async function loadCrypto(): Promise<typeof import('node:crypto')> {
+	return Function('specifier', 'return import(specifier)')('node:crypto');
+}
+
 export async function ensureDir(dir: string) {
-	const { mkdir, writeFile } = await loadFsPromises();
+	const { mkdir } = await loadFsPromises();
 	await mkdir(dir, { recursive: true }).catch(() => {});
-	await writeFile(joinPath(dir, '.keep'), '').catch(() => {});
 }
 
 export async function fileExists(p: string) {

package/src/core/src/tools/builtin/fs/copy-attachment.ts

@@ -3,6 +3,10 @@ import { copyFile, mkdir, readFile, stat } from 'node:fs/promises';
 import { dirname, extname, join } from 'node:path';
 import { tool, type Tool } from 'ai';
 import { z } from 'zod/v3';
+import {
+	loadConfig,
+	type OttoConfig,
+} from '../../../../../config/src/index.ts';
 import { createToolError, type ToolResponse } from '../../error.ts';
 import { expandTilde, isAbsoluteLike, resolveSafePath } from './util.ts';
 import { rememberFileWrite } from './read-tracker.ts';
@@ -16,10 +20,11 @@ type AttachmentMetadata = {
 	sha256: string;
 	kind: 'image' | 'pdf' | 'text' | 'binary';
 	originalPath: string;
+	storageRoot?: 'project-state';
+	relativePath?: string;
 	createdAt: string;
 };
 
-const ATTACHMENTS_DIR = '.otto/attachments';
 const MIME_EXTENSIONS: Record<string, string[]> = {
 	'image/png': ['.png'],
 	'image/jpeg': ['.jpg', '.jpeg'],
@@ -43,12 +48,11 @@ function replaceExtension(path: string, extension: string): string {
 }
 
 async function readAttachmentMetadata(
-	projectRoot: string,
+	cfg: OttoConfig,
 	attachmentId: string,
 ): Promise<AttachmentMetadata> {
 	const metadataPath = join(
-		projectRoot,
-		ATTACHMENTS_DIR,
+		cfg.paths.attachmentsDir,
 		attachmentId,
 		'metadata.json',
 	);
@@ -56,6 +60,19 @@ async function readAttachmentMetadata(
 	return JSON.parse(raw) as AttachmentMetadata;
 }
 
+function resolveAttachmentSource(
+	cfg: OttoConfig,
+	metadata: AttachmentMetadata,
+): string {
+	if (metadata.storageRoot === 'project-state' && metadata.relativePath) {
+		return join(cfg.paths.projectStateDir, metadata.relativePath);
+	}
+	return join(
+		cfg.paths.projectStateDir,
+		metadata.relativePath ?? metadata.originalPath,
+	);
+}
+
 export function buildCopyAttachmentTool(projectRoot: string): {
 	name: string;
 	tool: Tool;
@@ -83,8 +100,8 @@ export function buildCopyAttachmentTool(projectRoot: string): {
 		async execute({
 			attachmentId,
 			targetPath,
-			overwrite,
-			createDirs,
+			overwrite = false,
+			createDirs = true,
 		}: {
 			attachmentId: string;
 			targetPath: string;
@@ -132,11 +149,9 @@ export function buildCopyAttachmentTool(projectRoot: string): {
 			}
 
 			try {
-				const metadata = await readAttachmentMetadata(
-					projectRoot,
-					attachmentId,
-				);
-				const source = join(projectRoot, metadata.originalPath);
+				const cfg = await loadConfig(projectRoot);
+				const metadata = await readAttachmentMetadata(cfg, attachmentId);
+				const source = resolveAttachmentSource(cfg, metadata);
 				const expectedExtensions = getExpectedExtensions(metadata.mimeType);
 				const targetExtension = extname(requestedPath).toLowerCase();
 				const preferredExtension = expectedExtensions[0];
@@ -145,7 +160,7 @@ export function buildCopyAttachmentTool(projectRoot: string): {
 						? replaceExtension(requestedPath, preferredExtension)
 						: requestedPath;
 				const extensionAdjusted = req !== requestedPath;
-				const target = resolveSafePath(projectRoot, req);
+				const target = resolveSafePath(cfg.projectRoot, req);
 				try {
 					await stat(target);
 					if (!overwrite) {
@@ -168,7 +183,7 @@ export function buildCopyAttachmentTool(projectRoot: string): {
 					await mkdir(dirname(target), { recursive: true });
 				}
 				await copyFile(source, target);
-				await rememberFileWrite(projectRoot, target);
+				await rememberFileWrite(cfg.projectRoot, target);
 				const bytes = await readFile(target);
 				const sha256 = createHash('sha256').update(bytes).digest('hex');
 				return {

package/src/core/src/tools/builtin/git-identity.ts

@@ -1,10 +1,40 @@
+import { readFileSync } from 'node:fs';
+import { getGlobalConfigPath } from '../../../../config/src/paths.ts';
+
 const OTTOCODE_BOT_USER_ID = '261994719';
 
 export const OTTOCODE_BOT_NAME = 'ottocode-io[bot]';
 export const OTTOCODE_BOT_EMAIL = `${OTTOCODE_BOT_USER_ID}+${OTTOCODE_BOT_NAME}@users.noreply.github.com`;
 export const OTTOCODE_CO_AUTHOR = `Co-authored-by: ${OTTOCODE_BOT_NAME} <${OTTOCODE_BOT_EMAIL}>`;
 
-export function appendCoAuthorTrailer(message: string): string {
+type JsonObject = Record<string, unknown>;
+
+function readCoAuthorCommits(filePath: string): boolean | undefined {
+	try {
+		const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+		if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+			return undefined;
+		}
+		const defaults = (parsed as JsonObject).defaults;
+		if (!defaults || typeof defaults !== 'object' || Array.isArray(defaults)) {
+			return undefined;
+		}
+		const value = (defaults as JsonObject).coAuthorCommits;
+		return typeof value === 'boolean' ? value : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function shouldCoAuthorCommits(_projectRoot?: string): boolean {
+	return readCoAuthorCommits(getGlobalConfigPath()) ?? false;
+}
+
+export function appendCoAuthorTrailer(
+	message: string,
+	enabled = false,
+): string {
+	if (!enabled) return message;
 	if (message.includes(OTTOCODE_CO_AUTHOR)) return message;
 	return `${message}\n\n${OTTOCODE_CO_AUTHOR}`;
 }
@@ -12,9 +42,13 @@ export function appendCoAuthorTrailer(message: string): string {
 const GIT_COMMIT_MSG_RE =
 	/git\s+commit\s+(?:[^"']*?)(?:-[a-z]*m|-m)\s+(["'])([\s\S]*?)\1/g;
 
-export function injectCoAuthorIntoGitCommit(cmd: string): string {
+export function injectCoAuthorIntoGitCommit(
+	cmd: string,
+	enabled = false,
+): string {
+	if (!enabled) return cmd;
 	return cmd.replace(GIT_COMMIT_MSG_RE, (match, quote, msg) => {
-		const patched = appendCoAuthorTrailer(msg);
+		const patched = appendCoAuthorTrailer(msg, true);
 		return match.replace(
 			`${quote}${msg}${quote}`,
 			`${quote}${patched}${quote}`,

package/src/core/src/tools/builtin/git.ts

@@ -6,7 +6,10 @@ import GIT_STATUS_DESCRIPTION from './git.status.txt' with { type: 'text' };
 import GIT_DIFF_DESCRIPTION from './git.diff.txt' with { type: 'text' };
 import GIT_COMMIT_DESCRIPTION from './git.commit.txt' with { type: 'text' };
 import { createToolError, type ToolResponse } from '../error.ts';
-import { appendCoAuthorTrailer } from './git-identity.ts';
+import {
+	appendCoAuthorTrailer,
+	shouldCoAuthorCommits,
+} from './git-identity.ts';
 
 const execAsync = promisify(exec);
 
@@ -120,7 +123,10 @@ export function buildGitTools(
 				});
 			}
 			const gitRoot = await findGitRoot();
-			const fullMessage = appendCoAuthorTrailer(message);
+			const fullMessage = appendCoAuthorTrailer(
+				message,
+				shouldCoAuthorCommits(projectRoot),
+			);
 			const args = [
 				'git',
 				'-C',

package/src/core/src/tools/builtin/shell.ts

@@ -5,7 +5,10 @@ import { z } from 'zod/v3';
 import DESCRIPTION from './shell.txt' with { type: 'text' };
 import { getShellExecutionConfig } from '../bin-manager.ts';
 import { createToolError, type ToolResponse } from '../error.ts';
-import { injectCoAuthorIntoGitCommit } from './git-identity.ts';
+import {
+	injectCoAuthorIntoGitCommit,
+	shouldCoAuthorCommits,
+} from './git-identity.ts';
 
 function normalizePath(p: string) {
 	const normalized = p.replace(/\\/g, '/');
@@ -248,7 +251,10 @@ export function buildShellTool(projectRoot: string): {
 			}
 
 			const absCwd = resolveSafePath(projectRoot, cwd || '.');
-			const finalCmd = injectCoAuthorIntoGitCommit(cmd);
+			const finalCmd = injectCoAuthorIntoGitCommit(
+				cmd,
+				shouldCoAuthorCommits(projectRoot),
+			);
 			const shellExecutor = shellExecutorContext.getStore();
 			if (shellExecutor) {
 				return shellExecutor(

package/src/core/src/tools/builtin/terminal.ts

@@ -5,7 +5,10 @@ import { createToolError } from '../error.ts';
 import type { TerminalManager } from '../../terminals/index.ts';
 import type { TerminalStatus } from '../../terminals/terminal.ts';
 import { normalizeTerminalLine } from '../../utils/ansi.ts';
-import { injectCoAuthorIntoGitCommit } from './git-identity.ts';
+import {
+	injectCoAuthorIntoGitCommit,
+	shouldCoAuthorCommits,
+} from './git-identity.ts';
 
 function shellQuote(segment: string): string {
 	if (/^[a-zA-Z0-9._-]+$/.test(segment)) {
@@ -108,6 +111,7 @@ export function buildTerminalTool(
 		execute: async (params) => {
 			try {
 				const { operation } = params;
+				const coAuthorCommits = shouldCoAuthorCommits(projectRoot);
 
 				switch (operation) {
 					case 'start': {
@@ -169,7 +173,9 @@ export function buildTerminalTool(
 
 						if (initialCommand) {
 							queueMicrotask(() => {
-								term.write(`${injectCoAuthorIntoGitCommit(initialCommand)}\n`);
+								term.write(
+									`${injectCoAuthorIntoGitCommit(initialCommand, coAuthorCommits)}\n`,
+								);
 							});
 						}
 
@@ -243,7 +249,9 @@ export function buildTerminalTool(
 							return createToolError(`Terminal ${params.terminalId} not found`);
 						}
 
-						term.write(injectCoAuthorIntoGitCommit(params.input));
+						term.write(
+							injectCoAuthorIntoGitCommit(params.input, coAuthorCommits),
+						);
 
 						return {
 							ok: true,

package/src/index.ts

@@ -253,6 +253,20 @@ export type {
 export { loadConfig, read as readConfig } from './config/src/index.ts';
 export {
 	getLocalDataDir,
+	getLegacyProjectDataDir,
+	getOttoHomeDir,
+	getProjectsStateRoot,
+	getProjectId,
+	getProjectConfigDir,
+	getProjectConfigPath,
+	getProjectStateDir,
+	getProjectDbPath,
+	getProjectAttachmentsDir,
+	getProjectDebugDir,
+	getProjectDebugDumpsDir,
+	getProjectLogsDir,
+	getProjectTmpDir,
+	getProjectCacheDir,
 	getGlobalConfigDir,
 	getGlobalConfigPath,
 	getGlobalSkillsConfigPath,
@@ -334,6 +348,7 @@ export {
 export {
 	appendCoAuthorTrailer,
 	injectCoAuthorIntoGitCommit,
+	shouldCoAuthorCommits,
 	OTTOCODE_BOT_NAME,
 	OTTOCODE_BOT_EMAIL,
 	OTTOCODE_CO_AUTHOR,

package/src/providers/src/catalog-manual.ts

@@ -154,6 +154,18 @@ export function appendXaiGrokCliModels<T extends { models: ModelInfo[] }>(
 	return { ...entry, models: [...mergedModels, ...missingModels] };
 }
 
+const DEPRECATED_KIMI_MODEL_IDS = new Set([
+	'kimi-k2-0711-preview',
+	'kimi-k2-0905-preview',
+	'kimi-k2-thinking',
+	'kimi-k2-thinking-turbo',
+	'kimi-k2-turbo-preview',
+]);
+
+export function filterAvailableKimiModels(models: ModelInfo[]): ModelInfo[] {
+	return models.filter((model) => !DEPRECATED_KIMI_MODEL_IDS.has(model.id));
+}
+
 export function applyOfficialKimiCatalogMetadata<
 	T extends ProviderCatalogEntry,
 >(entry: T | undefined): T | undefined {
@@ -163,6 +175,7 @@ export function applyOfficialKimiCatalogMetadata<
 	);
 	return {
 		...entry,
+		models: filterAvailableKimiModels(entry.models),
 		label: entry.label === 'Moonshot AI' ? 'Kimi' : entry.label,
 		env,
 		doc: 'https://platform.kimi.ai/docs/api/overview.md',

package/src/providers/src/utils.ts

@@ -1,4 +1,5 @@
 import { catalog } from './catalog-merged.ts';
+import { filterAvailableKimiModels } from './catalog-manual.ts';
 import { getCachedProviderCatalogEntry } from './model-catalog-cache.ts';
 import { mergeModelLists } from './model-merge.ts';
 import type {
@@ -45,7 +46,7 @@ const PREFERRED_FAST_MODELS: Partial<Record<ProviderId, string[]>> = {
 	xai: ['grok-code-fast-1', 'grok-4-fast'],
 	zai: ['glm-4.5-flash'],
 	copilot: ['gpt-4.1-mini'],
-	moonshot: ['kimi-k2-turbo-preview'],
+	moonshot: ['kimi-k2.7-code'],
 };
 
 const PREFERRED_FAST_MODELS_OAUTH: Partial<Record<ProviderId, string[]>> = {
@@ -263,7 +264,10 @@ function getProviderModels(provider: ProviderId): ModelInfo[] {
 	const cachedModels = getCachedProviderCatalogEntry(
 		catalogProvider ?? provider,
 	)?.models;
-	return mergeModelLists(catalogModels, cachedModels);
+	const models = mergeModelLists(catalogModels, cachedModels);
+	return catalogProvider === 'moonshot'
+		? filterAvailableKimiModels(models)
+		: models;
 }
 
 export function modelSupportsReasoning(

package/src/types/src/config.ts

@@ -38,6 +38,8 @@ export type DefaultConfig = {
 	releaseToSend?: boolean;
 	fullWidthContent?: boolean;
 	autoCompactThresholdTokens?: number | null;
+	/** Adds the ottocode bot as a co-author on commits made through Otto. */
+	coAuthorCommits?: boolean;
 	/** Enables the otto supervisor agent and persistent goals (disabled together). */
 	ottoEnabled?: boolean;
 };
@@ -74,9 +76,17 @@ export type SkillSettings = {
  * Path configuration
  */
 export type PathConfig = {
+	projectConfigDir: string;
+	projectConfigPath: string | null;
+	projectStateDir: string;
 	dataDir: string;
 	dbPath: string;
-	projectConfigPath: string | null;
+	attachmentsDir: string;
+	debugDir: string;
+	debugDumpsDir: string;
+	logsDir: string;
+	tmpDir: string;
+	cacheDir: string;
 	globalConfigPath: string | null;
 };