@ottocode/sdk 0.1.312 → 0.1.314

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.312",
+	"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,11 +49,18 @@ const DEFAULTS: {
 		releaseToSend: false,
 		fullWidthContent: false,
 		autoCompactThresholdTokens: null,
+		coAuthorCommits: false,
 		ottoEnabled: true,
 	},
 	providers: DEFAULT_PROVIDER_SETTINGS,
 };
 
+const LOCAL_DEFAULT_OVERRIDE_KEYS = [
+	'agent',
+	'provider',
+	'model',
+] satisfies Array<keyof OttoConfig['defaults']>;
+
 export async function loadConfig(
 	projectRootInput?: string,
 ): Promise<OttoConfig> {
@@ -58,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();
 
@@ -72,10 +94,15 @@ export async function loadConfig(
 		DEFAULTS,
 		globalCfg,
 		globalSkillsCfg ? { skills: globalSkillsCfg } : undefined,
-		omitGlobalOnlySettings(projectCfg),
+		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,
@@ -83,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,
@@ -97,14 +132,32 @@ export async function loadConfig(
 
 type JsonObject = Record<string, unknown>;
 
-function omitGlobalOnlySettings(
+function filterProjectConfig(
 	config: JsonObject | undefined,
 ): JsonObject | undefined {
 	if (!config) return undefined;
-	const { providers: _providers, skills: _skills, ...rest } = config;
+	const { providers: _providers, skills: _skills, defaults, ...rest } = config;
+	const localDefaults = pickLocalDefaults(defaults);
+	if (localDefaults) {
+		return { ...rest, defaults: localDefaults };
+	}
 	return rest;
 }
 
+function pickLocalDefaults(defaults: unknown): JsonObject | undefined {
+	if (!defaults || typeof defaults !== 'object' || Array.isArray(defaults)) {
+		return undefined;
+	}
+	const source = defaults as JsonObject;
+	const picked: JsonObject = {};
+	for (const key of LOCAL_DEFAULT_OVERRIDE_KEYS) {
+		if (Object.hasOwn(source, key)) {
+			picked[key] = source[key];
+		}
+	}
+	return Object.keys(picked).length > 0 ? picked : undefined;
+}
+
 async function readJsonOptional(file: string): Promise<JsonObject | undefined> {
 	const f = Bun.file(file);
 	if (!(await f.exists())) return undefined;

package/src/config/src/manager.ts

@@ -28,6 +28,8 @@ import {
 
 export type Scope = 'global' | 'local';
 
+const LOCAL_DEFAULT_UPDATE_KEYS = new Set(['agent', 'provider', 'model']);
+
 export type DebugConfig = {
 	enabled: boolean;
 	scopes: string[];
@@ -91,10 +93,21 @@ export async function writeDefaults(
 		releaseToSend: boolean;
 		fullWidthContent: boolean;
 		autoCompactThresholdTokens: number | null;
+		coAuthorCommits: boolean;
 		ottoEnabled: boolean;
 	}>,
 	projectRoot?: string,
 ) {
+	const scopedUpdates =
+		scope === 'local'
+			? (Object.fromEntries(
+					Object.entries(updates).filter(([key]) =>
+						LOCAL_DEFAULT_UPDATE_KEYS.has(key),
+					),
+				) as typeof updates)
+			: updates;
+	if (Object.keys(scopedUpdates).length === 0) return;
+
 	const filePath = getConfigFilePath(scope, projectRoot);
 	const existing = await readJsonFile(filePath);
 	const prevDefaults =
@@ -103,7 +116,7 @@ export async function writeDefaults(
 			: {};
 	const next = {
 		...existing,
-		defaults: { ...prevDefaults, ...updates },
+		defaults: { ...prevDefaults, ...scopedUpdates },
 	};
 	await writeConfigFile(filePath, next);
 }

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

@@ -14,20 +14,6 @@ type CatalogMap = Partial<Record<BuiltInProviderId, ProviderCatalogEntry>>;
 const OLLAMA_CLOUD_ID: BuiltInProviderId = 'ollama-cloud';
 const OTTOROUTER_ID: BuiltInProviderId = 'ottorouter';
 
-const KIMI_K2_7_CODE_MODEL: ModelInfo = {
-	id: 'kimi-k2.7-code',
-	ownedBy: 'moonshot',
-	label: 'Kimi K2.7 Code',
-	modalities: { input: ['text', 'image', 'video'], output: ['text'] },
-	toolCall: true,
-	reasoningText: true,
-	attachment: true,
-	temperature: 1,
-	cost: { input: 0.95, output: 4, cacheRead: 0.19 },
-	limit: { context: 262_144, output: 32_768 },
-	provider: { npm: '@ai-sdk/openai-compatible' },
-};
-
 const XAI_GROK_CLI_MODELS: ModelInfo[] = [
 	{
 		id: 'grok-build',
@@ -168,24 +154,31 @@ export function appendXaiGrokCliModels<T extends { models: ModelInfo[] }>(
 	return { ...entry, models: [...mergedModels, ...missingModels] };
 }
 
-export function appendOfficialKimiModels<T extends ProviderCatalogEntry>(
-	entry: T | undefined,
-): T | undefined {
+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 {
 	if (!entry) return undefined;
-	const hasKimiK27Code = entry.models.some(
-		(model) => model.id === KIMI_K2_7_CODE_MODEL.id,
-	);
 	const env = Array.from(
 		new Set(['KIMI_API_KEY', 'MOONSHOT_API_KEY', ...(entry.env ?? [])]),
 	);
 	return {
 		...entry,
+		models: filterAvailableKimiModels(entry.models),
 		label: entry.label === 'Moonshot AI' ? 'Kimi' : entry.label,
 		env,
 		doc: 'https://platform.kimi.ai/docs/api/overview.md',
-		models: hasKimiK27Code
-			? entry.models
-			: [...entry.models, KIMI_K2_7_CODE_MODEL],
 	};
 }
 
@@ -202,7 +195,7 @@ export function mergeManualCatalog(
 	if (xaiEntry) {
 		merged.xai = xaiEntry;
 	}
-	const moonshotEntry = appendOfficialKimiModels(merged.moonshot);
+	const moonshotEntry = applyOfficialKimiCatalogMetadata(merged.moonshot);
 	if (moonshotEntry) {
 		merged.moonshot = moonshotEntry;
 	}

package/src/providers/src/catalog.ts

@@ -2343,13 +2343,13 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 					lastUpdated: '2026-04-27',
 					openWeights: false,
 					cost: {
-						input: 0.67,
-						output: 3.39,
-						cacheRead: 0.14,
+						input: 0.68,
+						output: 3.41,
+						cacheRead: 0.34,
 					},
 					limit: {
-						context: 262144,
-						output: 262144,
+						context: 262142,
+						output: 262142,
 					},
 				},
 				{
@@ -3231,7 +3231,7 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						cacheRead: 0.135,
 					},
 					limit: {
-						context: 32768,
+						context: 163840,
 						output: 16384,
 					},
 				},
@@ -3398,12 +3398,12 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 					lastUpdated: '2026-04-24',
 					openWeights: true,
 					cost: {
-						input: 0.0983,
-						output: 0.1966,
-						cacheRead: 0.0197,
+						input: 0.098,
+						output: 0.196,
+						cacheRead: 0.02,
 					},
 					limit: {
-						context: 1048576,
+						context: 1048575,
 						output: 131072,
 					},
 				},
@@ -4873,12 +4873,11 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 					lastUpdated: '2026-01',
 					openWeights: true,
 					cost: {
-						input: 0.4,
-						output: 1.9,
-						cacheRead: 0.09,
+						input: 0.375,
+						output: 2.025,
 					},
 					limit: {
-						context: 262144,
+						context: 256000,
 						output: 262144,
 					},
 				},
@@ -4899,9 +4898,35 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 					lastUpdated: '2026-04-21',
 					openWeights: true,
 					cost: {
-						input: 0.67,
-						output: 3.39,
-						cacheRead: 0.14,
+						input: 0.68,
+						output: 3.41,
+						cacheRead: 0.34,
+					},
+					limit: {
+						context: 262142,
+						output: 262142,
+					},
+				},
+				{
+					id: 'moonshotai/kimi-k2.7-code',
+					ownedBy: 'moonshot',
+					label: 'Kimi K2.7 Code',
+					modalities: {
+						input: ['text', 'image'],
+						output: ['text'],
+					},
+					toolCall: true,
+					reasoningText: true,
+					attachment: true,
+					temperature: true,
+					knowledge: '2025-01',
+					releaseDate: '2026-06-12',
+					lastUpdated: '2026-06-12',
+					openWeights: true,
+					cost: {
+						input: 0.75,
+						output: 3.5,
+						cacheRead: 0.16,
 					},
 					limit: {
 						context: 262144,
@@ -7633,12 +7658,12 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 					lastUpdated: '2026-04-22',
 					openWeights: true,
 					cost: {
-						input: 0.289,
-						output: 2.4,
+						input: 0.2885,
+						output: 3.17,
 					},
 					limit: {
-						context: 131072,
-						output: 131072,
+						context: 262140,
+						output: 262140,
 					},
 				},
 				{
@@ -10924,6 +10949,32 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						output: 131072,
 					},
 				},
+				{
+					id: 'glm-5.2',
+					ownedBy: 'zai',
+					label: 'GLM-5.2',
+					modalities: {
+						input: ['text'],
+						output: ['text'],
+					},
+					toolCall: true,
+					reasoningText: true,
+					attachment: false,
+					temperature: true,
+					releaseDate: '2026-06-13',
+					lastUpdated: '2026-06-13',
+					openWeights: false,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+					},
+					limit: {
+						context: 1000000,
+						output: 131072,
+					},
+				},
 				{
 					id: 'glm-5v-turbo',
 					ownedBy: 'zai',
@@ -12338,6 +12389,27 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						output: 262144,
 					},
 				},
+				{
+					id: 'kimi-k2.7-code',
+					ownedBy: 'moonshot',
+					label: 'kimi-k2.7-code',
+					modalities: {
+						input: ['text', 'image'],
+						output: ['text'],
+					},
+					toolCall: true,
+					reasoningText: true,
+					attachment: true,
+					temperature: false,
+					knowledge: '2025-01',
+					releaseDate: '2026-06-12',
+					lastUpdated: '2026-06-12',
+					openWeights: true,
+					limit: {
+						context: 262144,
+						output: 262144,
+					},
+				},
 				{
 					id: 'minimax-m2',
 					ownedBy: 'minimax',

package/src/providers/src/model-merge.ts

@@ -5,8 +5,8 @@ import type { ModelInfo } from '../../types/src/index.ts';
  *
  * Cached entries override fields for overlapping ids (so remote updates like
  * pricing/limits still apply), while embedded/manual-only models (for example
- * `kimi-k2.7-code` or the manual xai grok-cli models) are always retained even
- * when a stale cache does not include them.
+ * the manual xai grok-cli models) are always retained even when a stale cache
+ * does not include them.
  */
 export function mergeModelLists(
 	baseModels: ModelInfo[] | undefined,

package/src/providers/src/moonshot-client.ts

@@ -15,6 +15,90 @@ export function readKimiApiKeyFromEnv(): string {
 	return process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY || '';
 }
 
+/**
+ * Kimi/Moonshot streaming responses report token usage on the final chunk's
+ * `choices[0].usage` instead of the OpenAI-standard top-level `usage` field.
+ * The AI SDK openai-compatible parser only reads top-level `usage`, so we
+ * hoist choice-level usage to the top level when it is missing.
+ */
+export function hoistKimiSseUsage(line: string): string {
+	const hasCarriageReturn = line.endsWith('\r');
+	const raw = hasCarriageReturn ? line.slice(0, -1) : line;
+	if (!raw.startsWith('data:')) return line;
+	const payload = raw.slice(5).trim();
+	if (!payload || payload === '[DONE]') return line;
+	try {
+		const parsed = JSON.parse(payload) as {
+			usage?: unknown;
+			choices?: Array<{ usage?: unknown } | null>;
+		};
+		if (!parsed || typeof parsed !== 'object' || parsed.usage != null) {
+			return line;
+		}
+		const choiceUsage = Array.isArray(parsed.choices)
+			? parsed.choices.find((choice) => choice?.usage != null)?.usage
+			: undefined;
+		if (choiceUsage == null) return line;
+		parsed.usage = choiceUsage;
+		return `data: ${JSON.stringify(parsed)}${hasCarriageReturn ? '\r' : ''}`;
+	} catch {
+		return line;
+	}
+}
+
+/**
+ * Wraps fetch so Kimi SSE chunks carrying `choices[0].usage` are rewritten to
+ * expose a top-level `usage` field the AI SDK can parse.
+ */
+export function createKimiUsageFetch(
+	baseFetch: typeof fetch = fetch,
+): typeof fetch {
+	const wrappedFetch = async (
+		input: Parameters<typeof fetch>[0],
+		init?: Parameters<typeof fetch>[1],
+	): Promise<Response> => {
+		const response = await baseFetch(input, init);
+		const contentType = response.headers.get('content-type') ?? '';
+		if (
+			!response.ok ||
+			!response.body ||
+			!contentType.includes('text/event-stream')
+		) {
+			return response;
+		}
+
+		const decoder = new TextDecoder();
+		const encoder = new TextEncoder();
+		let buffered = '';
+		const transform = new TransformStream<Uint8Array, Uint8Array>({
+			transform(chunk, controller) {
+				buffered += decoder.decode(chunk, { stream: true });
+				const lines = buffered.split('\n');
+				buffered = lines.pop() ?? '';
+				for (const line of lines) {
+					controller.enqueue(encoder.encode(`${hoistKimiSseUsage(line)}\n`));
+				}
+			},
+			flush(controller) {
+				buffered += decoder.decode();
+				if (buffered.length) {
+					controller.enqueue(encoder.encode(hoistKimiSseUsage(buffered)));
+				}
+			},
+		});
+
+		const headers = new Headers(response.headers);
+		headers.delete('content-length');
+		headers.delete('content-encoding');
+		return new Response(response.body.pipeThrough(transform), {
+			status: response.status,
+			statusText: response.statusText,
+			headers,
+		});
+	};
+	return wrappedFetch as typeof fetch;
+}
+
 export function createKimiModel(model: string, config?: KimiProviderConfig) {
 	const entry = catalog.moonshot;
 	const oauthAccess = config?.oauth?.access;
@@ -34,6 +118,7 @@ export function createKimiModel(model: string, config?: KimiProviderConfig) {
 		name: 'Kimi',
 		baseURL,
 		headers,
+		fetch: createKimiUsageFetch(),
 	});
 
 	return instance(model);

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,18 +46,25 @@ 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.7-code'],
 };
 
 const PREFERRED_FAST_MODELS_OAUTH: Partial<Record<ProviderId, string[]>> = {
 	openai: ['gpt-5.4-mini'],
 	anthropic: ['claude-haiku-4-5'],
+	moonshot: ['kimi-k2.7-code'],
 };
 
+function preferredFastModelKey(provider: ProviderId): ProviderId {
+	return resolveBuiltInProviderCatalogId(provider) ?? provider;
+}
+
 export function getFastModel(provider: ProviderId): string | undefined {
 	const providerModels = getProviderModels(provider);
 	if (!providerModels.length) return undefined;
 
-	const preferred = PREFERRED_FAST_MODELS[provider] ?? [];
+	const preferred =
+		PREFERRED_FAST_MODELS[preferredFastModelKey(provider)] ?? [];
 	for (const modelId of preferred) {
 		if (providerModels.some((m) => m.id === modelId)) {
 			return modelId;
@@ -86,7 +94,7 @@ export function getFastModelForAuth(
 
 	const preferredMap =
 		authType === 'oauth' ? PREFERRED_FAST_MODELS_OAUTH : PREFERRED_FAST_MODELS;
-	const preferred = preferredMap[provider] ?? [];
+	const preferred = preferredMap[preferredFastModelKey(provider)] ?? [];
 	for (const modelId of preferred) {
 		if (filteredModels.some((m) => m.id === modelId)) {
 			return modelId;
@@ -256,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;
 };