aiex-cli 0.0.3 → 0.0.4-beta.1

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { C as name, D as doctorDiagnosticsTableRows, O as formatDoctorDiagnosticsJson, S as description, T as version, _ as PLACEHOLDER_SCHEMA, a as parseJsonSchema, b as createConfig, c as recognizeImageText, d as readAIConfig, f as writeAIConfig, g as DEFAULT_PROMPT_CONFIG, h as DEFAULT_MINERU_CONFIG, i as JsonSchemaDefinitionSchema, l as shouldUseImageOcrFallback, m as DEFAULT_MARKITDOWN_CONFIG, n as createMigrationConfig, o as toSnakeCase, p as DEFAULT_MARKER_CONFIG, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as getDefaultAIConfig, v as PLACEHOLDER_TEXT, w as package_default, x as seedConfig, y as AIConfigSchema } from "./doctor-collector-BVbuw5LY.mjs";
+import { A as formatDoctorDiagnosticsJson, C as seedConfig, D as version, E as package_default, S as createConfig, T as name, _ as DEFAULT_MINERU_CONFIG, a as parseJsonSchema, b as PLACEHOLDER_TEXT, c as recognizeImageText, d as t, f as getDefaultAIConfig, g as DEFAULT_MARKITDOWN_CONFIG, h as DEFAULT_MARKER_CONFIG, i as JsonSchemaDefinitionSchema, k as doctorDiagnosticsTableRows, l as shouldUseImageOcrFallback, m as writeAIConfig, n as createMigrationConfig, o as toSnakeCase, p as readAIConfig, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as initI18n, v as DEFAULT_PROMPT_CONFIG, w as description, x as AIConfigSchema, y as PLACEHOLDER_SCHEMA } from "./doctor-collector-xRnW5Rj3.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -156,11 +156,11 @@ function generateCompletionScript(name$1, shell) {
 const completionCommand = defineCommand({
 	meta: {
 		name: "completion",
-		description: "Generate shell completion scripts (bash|zsh|fish)\n\nUsage:\n  aiex completion bash  # source <(aiex completion bash)\n  aiex completion zsh   # source <(aiex completion zsh)\n  aiex completion fish  # aiex completion fish | source"
+		description: t("command.completion.description")
 	},
 	args: { shell: {
 		type: "positional",
-		description: "Shell type: bash, zsh, fish",
+		description: t("command.completion.args.shell"),
 		required: true
 	} },
 	async run({ args }) {
@@ -169,7 +169,7 @@ const completionCommand = defineCommand({
 		try {
 			process.stdout.write(generateCompletionScript(name$1, shell));
 		} catch (error) {
-			process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
+			process.stderr.write(`${t("command.completion.error", { error: error instanceof Error ? error.message : String(error) })}\n`);
 			process.exit(1);
 		}
 	}
@@ -180,11 +180,11 @@ const completionCommand = defineCommand({
 const doctorCommand = defineCommand({
 	meta: {
 		name: "doctor",
-		description: "Print environment and configuration diagnostics"
+		description: t("command.doctor.description")
 	},
 	args: { json: {
 		type: "boolean",
-		description: "Print diagnostics as JSON"
+		description: t("command.doctor.args.json")
 	} },
 	async run({ args }) {
 		try {
@@ -194,15 +194,15 @@ const doctorCommand = defineCommand({
 				return;
 			}
 			consola.info(`${diagnostics.cli.name} ${diagnostics.cli.version}`);
-			const t = new CliTable3({
-				head: ["key", "value"],
+			const table = new CliTable3({
+				head: [t("command.doctor.headers.0"), t("command.doctor.headers.1")],
 				colAligns: ["right", "left"],
 				style: { compact: true }
 			});
-			t.push(...doctorDiagnosticsTableRows(diagnostics));
-			process.stdout.write(`${t.toString()}\n`);
+			table.push(...doctorDiagnosticsTableRows(diagnostics));
+			process.stdout.write(`${table.toString()}\n`);
 		} catch (err) {
-			consola.error(`Doctor diagnostics failed: ${err}`);
+			consola.error(t("command.doctor.diagnosticsFailed", { error: err }));
 		}
 	}
 });
@@ -211,7 +211,7 @@ const doctorCommand = defineCommand({
 //#region src/commands/utils.ts
 function failCommand(message) {
 	if (message) consola.error(message);
-	outro("Failed!");
+	outro(t("common.failed"));
 	process.exitCode = 1;
 }
 
@@ -12875,15 +12875,18 @@ function filterCompatible(models, inputTokens, outputTokens) {
 }
 function selectModel(input) {
 	const { models, isImage, fileName, inputTokens, outputTokens } = input;
-	if (models.length === 0) throw new Error("No AI models configured. Please add at least one model in AI Settings.");
+	if (models.length === 0) throw new Error(t("errors.ai.noModels"));
 	let candidates = filterCompatible(models, inputTokens, outputTokens);
 	if (candidates.length === 0) candidates = models;
 	if (isImage) {
 		const visionModel = candidates.find((m) => m.capabilities.vision);
 		if (!visionModel) {
 			const hint = fileName ? ` (${fileName})` : "";
-			const msg = inputTokens ? `No vision-capable model with sufficient context window (≥${inputTokens} tokens) found${hint}.` : `Image input requires a model with vision capability${hint}.`;
-			throw new Error(`${msg} Please add a suitable vision-capable model in AI Settings.`);
+			const msg = inputTokens ? t("errors.ai.noVisionModelContext", {
+				tokens: inputTokens,
+				hint
+			}) : t("errors.ai.noVisionModel", { hint });
+			throw new Error(msg + t("errors.ai.addSuitableModel"));
 		}
 		return {
 			name: visionModel.name,
@@ -13140,7 +13143,7 @@ async function extractStructuredData(input) {
 	const { config, schema, text: text$1, aiexDir, file, modelOverride } = input;
 	if (!config.provider.apiKey) return {
 		success: false,
-		error: "API Key not configured. Please configure AI settings in the web UI."
+		error: t("errors.ai.apiKeyMissing")
 	};
 	const useFileContent = !!file;
 	const isImageFile = useFileContent && detectMimeType(file).startsWith("image/");
@@ -13345,7 +13348,7 @@ function insertExtractedData(db, schema, data) {
 				const [propName] = propEntry;
 				const nestedValue = data[propName];
 				if (nestedValue === null || nestedValue === void 0) continue;
-				const nestedTable = parseResult.tables.find((t) => t.name === revRel.toTable);
+				const nestedTable = parseResult.tables.find((t$1) => t$1.name === revRel.toTable);
 				if (!nestedTable) continue;
 				if (revRel.type === "has-one") {
 					const rowId = insertTableRow({
@@ -13440,7 +13443,7 @@ async function createExtractionAuditRecord(aiexDir, input) {
 }
 async function updateExtractionAuditRecord(aiexDir, id, patch) {
 	const current = await readExtractionAuditRecord(aiexDir, id);
-	if (!current) throw new Error(`Extraction audit record not found: ${id}`);
+	if (!current) throw new Error(t("errors.extractionAudit.recordNotFound", { id }));
 	const record = {
 		...current,
 		...patch,
@@ -13473,7 +13476,7 @@ async function markStaleIfNeeded(aiexDir, record) {
 	const staleRecord = {
 		...record,
 		status: "stale",
-		error: record.error ?? "Extraction did not finish. It may have been interrupted.",
+		error: record.error ?? t("errors.extractionAudit.interrupted"),
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
 	await writeFile(auditPath(aiexDir, staleRecord.id), staleRecord, {
@@ -13543,7 +13546,7 @@ async function findSucceededAuditByHash(aiexDir, schemaName, fileHash) {
 const MAX_UPLOAD_SIZE = 30 * 1024 * 1024;
 const MAX_UPLOAD_SIZE_TEXT = "30MB";
 const SUPPORTED_FILE_TYPES_TEXT = "images, PDF, text, markdown, CSV, JSON, HTML, XML, YAML";
-const MISSING_UPLOAD_FILE_TEXT = "Uploaded file is no longer available. Re-run extraction with the original file.";
+const MISSING_UPLOAD_FILE_TEXT = t("errors.file.missingUpload");
 const SUPPORTED_MIME_TYPES = new Set([
 	"image/png",
 	"image/jpeg",
@@ -13588,7 +13591,10 @@ function isAllowedMimeType(mimeType) {
 	return SUPPORTED_MIME_TYPES.has(mimeType);
 }
 function unsupportedFileTypeMessage(mimeType) {
-	return `Unsupported file type "${mimeType}". Supported: ${SUPPORTED_FILE_TYPES_TEXT}.`;
+	return t("errors.file.unsupportedType", {
+		type: mimeType,
+		supported: SUPPORTED_FILE_TYPES_TEXT
+	});
 }
 function isMissingUploadFileError(error) {
 	return !!error && typeof error === "object" && error.code === "ENOENT";
@@ -13600,8 +13606,12 @@ var FileValidationError = class extends Error {
 	}
 };
 function validateFileUpload(file) {
-	if (file.size === 0) throw new FileValidationError("Uploaded file is empty");
-	if (file.size > MAX_UPLOAD_SIZE) throw new FileValidationError(`File size (${bytesToMB(file.size).toFixed(1)}MB) exceeds ${MAX_UPLOAD_SIZE_TEXT} limit`);
+	if (file.size === 0) throw new FileValidationError(t("errors.file.empty"));
+	if (file.size > MAX_UPLOAD_SIZE) throw new FileValidationError(t("errors.file.sizeExceeded", {
+		size: bytesToMB(file.size).toFixed(1),
+		limit: MAX_UPLOAD_SIZE_TEXT,
+		file: file.name
+	}));
 	if (!isAllowedMimeType(file.type)) throw new FileValidationError(unsupportedFileTypeMessage(file.type));
 }
 
@@ -13756,7 +13766,7 @@ function firstDataSourceId(database) {
 }
 async function resolveNotionDataSource(notion, inputId) {
 	const id = parseNotionDatabaseId(inputId);
-	if (!id) throw new Error("Notion database or data source URL/ID is required.");
+	if (!id) throw new Error(t("errors.notion.idRequired"));
 	try {
 		const dataSource$1 = await notion.dataSources.retrieve({ data_source_id: id });
 		if (isDataSourceResponse(dataSource$1)) return {
@@ -13768,9 +13778,9 @@ async function resolveNotionDataSource(notion, inputId) {
 	} catch {}
 	const database = await notion.databases.retrieve({ database_id: id });
 	const dataSourceId = firstDataSourceId(database);
-	if (!dataSourceId) throw new Error("No data source found for this Notion database. Copy the data source link from Notion, or share the source database with the integration.");
+	if (!dataSourceId) throw new Error(t("errors.notion.noDataSource"));
 	const dataSource = await notion.dataSources.retrieve({ data_source_id: dataSourceId });
-	if (!isDataSourceResponse(dataSource)) throw new Error("Notion data source did not return properties. Make sure it is shared with the integration and is not a linked data source.");
+	if (!isDataSourceResponse(dataSource)) throw new Error(t("errors.notion.noProperties"));
 	return {
 		databaseId: database.id,
 		dataSourceId: dataSource.id,
@@ -13779,9 +13789,9 @@ async function resolveNotionDataSource(notion, inputId) {
 	};
 }
 async function inspectNotionDatabase(input) {
-	if (!input.token.trim()) throw new Error("Notion integration token is required.");
+	if (!input.token.trim()) throw new Error(t("errors.notion.tokenRequired"));
 	const id = parseNotionDatabaseId(input.databaseId);
-	if (!id) throw new Error("Notion database or data source URL/ID is required.");
+	if (!id) throw new Error(t("errors.notion.idRequired"));
 	const resolved = await resolveNotionDataSource(new Client({ auth: input.token }), id);
 	const databaseProperties = resolved.properties;
 	const titleProperty = findTitleProperty(databaseProperties) ?? void 0;
@@ -13797,8 +13807,8 @@ async function inspectNotionDatabase(input) {
 	};
 }
 function validateNotionConfig(config) {
-	if (!config?.enabled) return "Notion export is not enabled. Configure Notion settings first.";
-	if (!config.token.trim()) return "Notion integration token is required.";
+	if (!config?.enabled) return t("errors.notion.notEnabled");
+	if (!config.token.trim()) return t("errors.notion.tokenRequired");
 	return null;
 }
 async function writeNotionPage(config, schemaName, data) {
@@ -13806,8 +13816,8 @@ async function writeNotionPage(config, schemaName, data) {
 	if (configError) throw new Error(configError);
 	const notionConfig = config;
 	const schemaConfig = notionConfig.schemas[schemaName];
-	if (!schemaConfig) throw new Error(`Notion database is not configured for schema "${schemaName}".`);
-	if (!schemaConfig.databaseId.trim()) throw new Error(`Notion database ID is required for schema "${schemaName}".`);
+	if (!schemaConfig) throw new Error(t("errors.notion.noSchemaConfig", { name: schemaName }));
+	if (!schemaConfig.databaseId.trim()) throw new Error(t("errors.notion.noDatabaseId", { name: schemaName }));
 	const notion = new Client({ auth: notionConfig.token });
 	const resolved = await resolveNotionDataSource(notion, schemaConfig.databaseId);
 	const databaseProperties = resolved.properties;
@@ -13825,7 +13835,7 @@ async function writeNotionPage(config, schemaName, data) {
 	}
 	const titleProperty = findTitleProperty(databaseProperties, schemaConfig.titleProperty);
 	if (titleProperty && !properties[titleProperty]) properties[titleProperty] = buildPropertyValue("title", schemaName);
-	if (Object.keys(properties).length === 0) throw new Error("No extracted fields matched Notion database properties.");
+	if (Object.keys(properties).length === 0) throw new Error(t("errors.notion.noFieldsMatched"));
 	return {
 		pageId: (await notion.pages.create({
 			parent: resolved.parent,
@@ -13962,7 +13972,10 @@ var FallbackPdfConverter = class {
 		try {
 			return await this.primary.convert(input, filePath);
 		} catch (err) {
-			consola.warn(`${this.primary.name} failed: ${err instanceof Error ? err.message : String(err)}`);
+			consola.warn(t("command.extract.file.errorProcessing", {
+				name: this.primary.name,
+				error: err instanceof Error ? err.message : String(err)
+			}));
 			consola.info(`Falling back to ${this.fallback.name}`);
 			const result = await this.fallback.convert(input, filePath);
 			return {
@@ -13994,14 +14007,14 @@ function createPdfConverter(config) {
 			return withFallback(new ExternalCommandPdfConverter("marker", markerConfig), markerConfig);
 		}
 		if (config.converter === "external") {
-			if (!config.external) throw new Error("External PDF converter is selected but no external command is configured.");
+			if (!config.external) throw new Error(t("errors.pdf.externalNotConfigured"));
 			return withFallback(new ExternalCommandPdfConverter("external", config.external), config.external);
 		}
 	}
 	const key = typeof config === "string" ? config : "unpdf";
 	let instance = registry.get(key);
 	if (!instance) {
-		if (key !== "unpdf") throw new Error(`PDF converter "${key}" requires configuration.`);
+		if (key !== "unpdf") throw new Error(t("errors.pdf.converterRequiresConfig", { name: key }));
 		instance = new UnpdfConverter();
 		registry.set(key, instance);
 	}
@@ -14050,7 +14063,7 @@ const PDF_EXT_RE = /\.pdf$/i;
 const JSON_EXT_RE$1 = /\.json$/;
 const SUPPORTED_FILE_PATTERN = `*.{${[...SUPPORTED_EXTENSIONS$1].join(",")}}`;
 async function syncResultToNotion(aiConfig, schemaName, data) {
-	if (!data || typeof data !== "object" || Array.isArray(data)) throw new Error("Extraction result is not an object and cannot be written to Notion.");
+	if (!data || typeof data !== "object" || Array.isArray(data)) throw new Error(t("errors.ai.extractionNotObject"));
 	const page = await writeNotionPage(aiConfig.notion, schemaName, data);
 	return [{
 		databaseId: page.databaseId,
@@ -14064,23 +14077,29 @@ async function ensureDatabaseReady(dbPath, schema) {
 	try {
 		await fs.access(dbPath);
 	} catch {
-		return `Database not found at ${pc.cyan(".aiex/database.db")}. Run ${pc.cyan("aiex schema")} first to create the database.`;
+		return t("errors.db.notFound", {
+			path: pc.cyan(".aiex/database.db"),
+			cmd: pc.cyan("aiex schema")
+		});
 	}
 	try {
 		const result = parseJsonSchema(schema);
 		const db = new Database(dbPath);
 		try {
-			for (const table of result.tables) if (!db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(table.name)) return `Table "${table.name}" not found in database. Run ${pc.cyan("aiex schema")} first to create tables.`;
+			for (const table of result.tables) if (!db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(table.name)) return t("errors.db.tableNotFound", {
+				name: table.name,
+				cmd: pc.cyan("aiex schema")
+			});
 		} finally {
 			db.close();
 		}
 	} catch (e) {
-		return `Cannot verify database: ${e instanceof Error ? e.message : String(e)}`;
+		return t("errors.db.cannotVerify", { error: e instanceof Error ? e.message : String(e) });
 	}
 	return null;
 }
 function listSupportedFiles(dir, pattern) {
-	if (!fs$1.statSync(dir).isDirectory()) throw new Error(`Not a directory: ${dir}`);
+	if (!fs$1.statSync(dir).isDirectory()) throw new Error(t("errors.file.notADirectory", { dir }));
 	return globSync(pattern ?? SUPPORTED_FILE_PATTERN, {
 		cwd: dir,
 		absolute: true,
@@ -14098,15 +14117,18 @@ async function loadSchema(config, schemaName) {
 	} catch (e) {
 		if (e instanceof ZodError) return {
 			schema: null,
-			error: `Schema validation failed: ${schemaName}.json\n${e.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}`
+			error: t("errors.schema.validationFailed", {
+				name: `${schemaName}.json`,
+				issues: e.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")
+			})
 		};
 		if (e.code === "ENOENT") return {
 			schema: null,
-			error: `Cannot read schema file: ${schemaName}.json`
+			error: t("errors.schema.cannotRead", { name: `${schemaName}.json` })
 		};
 		if (e instanceof SyntaxError) return {
 			schema: null,
-			error: `Invalid JSON in schema file: ${schemaName}.json`
+			error: t("errors.schema.invalidJson", { name: `${schemaName}.json` })
 		};
 		return {
 			schema: null,
@@ -14124,12 +14146,16 @@ async function listSchemas(aiexDir) {
 }
 async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 	const stat = fs$1.statSync(filePath);
-	if (stat.size > MAX_UPLOAD_SIZE) throw new Error(`File size (${bytesToMB(stat.size).toFixed(1)}MB) exceeds ${MAX_UPLOAD_SIZE_TEXT} limit: ${filePath}`);
+	if (stat.size > MAX_UPLOAD_SIZE) throw new Error(t("errors.file.sizeExceeded", {
+		size: bytesToMB(stat.size).toFixed(1),
+		limit: MAX_UPLOAD_SIZE_TEXT,
+		file: filePath
+	}));
 	const ext = path.extname(filePath).toLowerCase().replace(".", "");
 	if (FILE_PART_EXTENSIONS.has(ext)) {
 		if (shouldUseImageOcrFallback(aiConfig, modelOverride)) {
 			const result = await recognizeImageText(filePath, aiConfig?.image);
-			consola.info(`Extracted image text via local OCR (confidence: ${(result.confidence * 100).toFixed(1)}%)`);
+			consola.info(t("extract.file.ocrText", { confidence: (result.confidence * 100).toFixed(1) }));
 			return { text: result.text };
 		}
 		return {
@@ -14141,16 +14167,19 @@ async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 		const buffer = await fs.readFile(filePath);
 		const converter = createPdfConverter(aiConfig?.pdf);
 		const result = await converter.convert(buffer, filePath);
-		if (result.metadata?.fallback === "true") consola.info(`Fell back to unpdf — ${result.pageCount} page(s) extracted`);
-		else consola.info(`Converted PDF via ${converter.name}, ${result.pageCount} page(s)`);
+		if (result.metadata?.fallback === "true") consola.info(t("extract.file.pdfFallback", { count: result.pageCount }));
+		else consola.info(t("extract.file.pdfConverted", {
+			name: converter.name,
+			count: result.pageCount
+		}));
 		const mdPath = filePath.replace(PDF_EXT_RE, ".md");
 		try {
 			await fs.writeFile(mdPath, result.text);
-			consola.info(`Markdown saved: ${mdPath}`);
+			consola.info(t("extract.file.markdownSaved", { path: mdPath }));
 		} catch {
 			const fallbackMd = path.join(os.tmpdir(), `${path.basename(filePath, ".pdf")}.md`);
 			await fs.writeFile(fallbackMd, result.text);
-			consola.info(`Markdown saved: ${fallbackMd}`);
+			consola.info(t("extract.file.markdownSaved", { path: fallbackMd }));
 		}
 		return { text: result.text };
 	}
@@ -14166,7 +14195,7 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 		};
 	}
 	const s = spinner();
-	if (!options?.quiet) s.start(filePath ? `Extracting from ${path.basename(filePath)}...` : "Extracting data...");
+	if (!options?.quiet) s.start(filePath ? t("extract.file.extractedFrom", { file: path.basename(filePath) }) : t("extract.file.extracting"));
 	const result = await extractStructuredData({
 		config: aiConfig,
 		schema: schemaLoad.schema,
@@ -14175,28 +14204,37 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 		file: filePath,
 		modelOverride,
 		onRetry(info) {
-			if (!options?.quiet) s.message(`API responded with ${info.statusCode}, retrying in ${info.delayMs / 1e3}s (${info.attempt}/${info.maxRetries})...`);
+			if (!options?.quiet) s.message(t("extract.file.extractRetry", {
+				code: info.statusCode,
+				delay: info.delayMs / 1e3,
+				attempt: info.attempt,
+				max: info.maxRetries
+			}));
 		}
 	});
 	if (!result.success) {
 		if (!options?.quiet) {
-			s.stop("Extraction failed");
-			consola.error(result.error || "Unknown error");
+			s.stop(t("extract.file.extractFail"));
+			consola.error(result.error || t("common.unknownError"));
 		}
 		return {
 			success: false,
-			error: result.error || "Unknown error"
+			error: result.error || t("common.unknownError")
 		};
 	}
-	if (!options?.quiet) s.stop("Extraction complete");
-	if (result.outputPath && !options?.quiet) consola.success(`Result saved: ${pc.cyan(result.outputPath)}`);
-	if (result.tokensUsed && !options?.quiet) consola.info(pc.gray(`Token usage: prompt=${result.tokensUsed.prompt}, completion=${result.tokensUsed.completion}, total=${result.tokensUsed.total}`));
+	if (!options?.quiet) s.stop(t("extract.file.extractComplete"));
+	if (result.outputPath && !options?.quiet) consola.success(t("extract.file.resultSaved", { path: pc.cyan(result.outputPath) }));
+	if (result.tokensUsed && !options?.quiet) consola.info(pc.gray(t("extract.file.tokenUsage", {
+		prompt: result.tokensUsed.prompt,
+		completion: result.tokensUsed.completion,
+		total: result.tokensUsed.total
+	})));
 	if (result.data && options?.insert !== false) {
 		const s2 = spinner();
-		if (!options?.quiet) s2.start("Inserting into database...");
+		if (!options?.quiet) s2.start(t("extract.file.insertingDb"));
 		const dbError = await ensureDatabaseReady(config.databasePath, schemaLoad.schema);
 		if (dbError) {
-			if (!options?.quiet) s2.stop("Database not ready");
+			if (!options?.quiet) s2.stop(t("extract.file.dbNotReady"));
 			consola.error(dbError);
 			return {
 				success: false,
@@ -14208,7 +14246,7 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 			try {
 				const insertResult = insertExtractedData(db, schemaLoad.schema, result.data);
 				if (insertResult.success) {
-					if (!options?.quiet) s2.stop(`Inserted into ${insertResult.tablesInserted.length} table(s)`);
+					if (!options?.quiet) s2.stop(t("extract.file.insertedTables", { count: insertResult.tablesInserted.length }));
 					return {
 						success: true,
 						outputPath: result.outputPath,
@@ -14217,8 +14255,8 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 						tokensUsed: result.tokensUsed
 					};
 				} else {
-					if (!options?.quiet) s2.stop("Database insert failed");
-					consola.error(insertResult.error || "Unknown error");
+					if (!options?.quiet) s2.stop(t("extract.file.dbInsertFail"));
+					consola.error(insertResult.error || t("common.unknownError"));
 					return {
 						success: false,
 						error: insertResult.error
@@ -14228,7 +14266,7 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 				db.close();
 			}
 		} catch (e) {
-			if (!options?.quiet) s2.stop("Database insert failed");
+			if (!options?.quiet) s2.stop(t("extract.file.dbInsertFail"));
 			consola.error(e instanceof Error ? e.message : String(e));
 			return {
 				success: false,
@@ -14262,12 +14300,18 @@ async function runAuditedExtraction(options) {
 		try {
 			fileHash = await getFileHash(source.filePath);
 		} catch (e) {
-			if (!quiet) consola.warn(`Failed to calculate file hash for ${path.basename(source.filePath)}: ${e instanceof Error ? e.message : String(e)}`);
+			if (!quiet) consola.warn(t("extract.file.hashWarning", {
+				file: path.basename(source.filePath),
+				error: e instanceof Error ? e.message : String(e)
+			}));
 		}
 		if (fileHash && !isPlainTextFile && !force) {
 			const existing = await findSucceededAuditByHash(aiexDir, schemaName, fileHash);
 			if (existing) {
-				if (!quiet) consola.info(`File ${pc.cyan(path.basename(source.filePath))} (hash: ${fileHash.slice(0, 8)}) has already been processed successfully. Skipping.`);
+				if (!quiet) consola.info(t("extract.file.alreadyProcessed", {
+					file: pc.cyan(path.basename(source.filePath)),
+					hash: fileHash.slice(0, 8)
+				}));
 				return {
 					success: true,
 					skipped: true,
@@ -14312,7 +14356,7 @@ async function runAuditedExtraction(options) {
 			let notionPages;
 			if (shouldSyncNotion(aiConfig, schemaName)) try {
 				notionPages = await syncResultToNotion(aiConfig, schemaName, r.data);
-				if (!quiet) consola.success(`Synced to Notion: ${notionPages.length} page(s)`);
+				if (!quiet) consola.success(t("extract.file.notionSynced", { count: notionPages.length }));
 			} catch (error) {
 				await updateExtractionAuditRecord(aiexDir, audit.id, {
 					status: "failed",
@@ -14322,7 +14366,7 @@ async function runAuditedExtraction(options) {
 					tokensUsed: r.tokensUsed,
 					error: error instanceof Error ? error.message : String(error)
 				});
-				if (!quiet) consola.error(`Notion sync failed: ${error instanceof Error ? error.message : String(error)}`);
+				if (!quiet) consola.error(t("extract.file.notionSyncFail", { error: error instanceof Error ? error.message : String(error) }));
 				return {
 					success: false,
 					error: error instanceof Error ? error.message : String(error),
@@ -14353,7 +14397,7 @@ async function runAuditedExtraction(options) {
 				status: "failed",
 				error: r.error || "Extraction failed"
 			});
-			if (!quiet) consola.error(`Failed: ${r.error}`);
+			if (!quiet) consola.error(t("extract.file.extractionFailed", { error: r.error }));
 			return {
 				success: false,
 				error: r.error,
@@ -14368,7 +14412,10 @@ async function runAuditedExtraction(options) {
 		});
 		if (!quiet) {
 			const name$1 = source.type === "file" ? path.basename(source.filePath) : "text input";
-			consola.error(`Error processing ${name$1}: ${e instanceof Error ? e.message : String(e)}`);
+			consola.error(t("extract.file.errorProcessing", {
+				name: name$1,
+				error: e instanceof Error ? e.message : String(e)
+			}));
 		}
 		return {
 			success: false,
@@ -14394,13 +14441,13 @@ async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, m
 		quiet: false
 	});
 	if (result.success) {
-		if (!result.skipped) consola.success(`Processed: ${path.basename(filePath)}`);
+		if (!result.skipped) consola.success(t("extract.file.processSuccess", { file: path.basename(filePath) }));
 		return true;
 	}
 	return false;
 }
 async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, globPattern, modelOverride, options) {
-	consola.info(`Scanning ${pc.cyan(dir)} for supported files...`);
+	consola.info(t("extract.batch.scanning", { dir: pc.cyan(dir) }));
 	let files;
 	try {
 		files = listSupportedFiles(dir, globPattern);
@@ -14409,28 +14456,36 @@ async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, gl
 			ok: false,
 			successCount: 0,
 			failCount: 0,
-			error: `Cannot read directory: ${dir}`
+			error: t("extract.batch.errors.cannotReadDir", { dir })
 		};
 	}
 	if (files.length === 0) return {
 		ok: false,
 		successCount: 0,
 		failCount: 0,
-		error: `No supported files found in ${dir}`
+		error: t("extract.batch.errors.noSupportedFiles", { dir })
 	};
-	consola.info(`Found ${files.length} file(s) to process`);
+	consola.info(t("extract.batch.found", { count: files.length }));
 	let successCount = 0;
 	let failCount = 0;
 	for (let i = 0; i < files.length; i++) {
 		const file = files[i];
-		consola.info(`\n[${i + 1}/${files.length}] Processing: ${pc.cyan(path.basename(file))}`);
+		consola.info(`\n${t("extract.batch.processing", {
+			current: i + 1,
+			total: files.length,
+			file: pc.cyan(path.basename(file))
+		})}`);
 		if (await processOneFile(aiexDir, config, aiConfig, schemaName, file, modelOverride, {
 			insert: options?.insert,
 			force: options?.force
 		})) successCount++;
 		else failCount++;
 	}
-	consola.info(`\nBatch complete: ${pc.green(`${successCount} succeeded`)}, ${pc.red(`${failCount} failed`)}, ${files.length} total`);
+	consola.info(`\n${t("extract.batch.complete", {
+		success: pc.green(successCount),
+		fail: pc.red(failCount),
+		total: files.length
+	})}`);
 	return {
 		ok: true,
 		successCount,
@@ -14443,34 +14498,35 @@ async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, gl
 const dumpCommand = defineCommand({
 	meta: {
 		name: "dump",
-		description: "Dump SQLite database table to Excel (.xlsx) or CSV (.csv)"
+		description: t("command.dump.description")
 	},
 	args: {
 		table: {
 			type: "string",
 			alias: "t",
-			description: "SQLite table name to export"
+			description: t("command.dump.args.table")
 		},
 		schema: {
 			type: "string",
 			alias: "s",
-			description: "Schema name (without .json extension) to export"
+			description: t("command.dump.args.schema")
 		},
 		format: {
 			type: "string",
 			alias: "f",
-			description: "Export format: csv or xlsx (default: inferred from output or csv)"
+			description: t("command.dump.args.format")
 		},
 		output: {
 			type: "string",
 			alias: "o",
-			description: "Output file path (default: ./<tableName>.<format>)"
+			description: t("command.dump.args.output")
 		}
 	},
 	async run({ args }) {
 		intro(pc.inverse(" aiex dump "));
+		await initI18n();
 		if (!args.table && !args.schema) {
-			failCommand("Either table name (--table / -t) or schema name (--schema / -s) is required");
+			failCommand(t("command.dump.errors.tableOrSchemaRequired"));
 			return;
 		}
 		const cwd = process.cwd();
@@ -14481,17 +14537,20 @@ const dumpCommand = defineCommand({
 		if (args.schema) {
 			const schemaLoad = await loadSchema(config, args.schema);
 			if (!schemaLoad.schema) {
-				failCommand(schemaLoad.error || `Schema file for "${args.schema}" not found`);
+				failCommand(schemaLoad.error || t("command.dump.errors.schemaNotFound", { name: args.schema }));
 				return;
 			}
 			schema = schemaLoad.schema;
 			const tName = schema.table?.name;
 			if (!tName) {
-				failCommand(`Schema "${args.schema}" does not define a database table name.`);
+				failCommand(t("command.dump.errors.noTableName", { name: args.schema }));
 				return;
 			}
 			if (tableName && tableName !== tName) {
-				failCommand(`Specified table name "${tableName}" does not match schema table name "${tName}"`);
+				failCommand(t("command.dump.errors.tableMismatch", {
+					table: tableName,
+					schemaTable: tName
+				}));
 				return;
 			}
 			tableName = tName;
@@ -14518,16 +14577,19 @@ const dumpCommand = defineCommand({
 		}
 		if (!format) format = "csv";
 		if (format !== "csv" && format !== "xlsx") {
-			failCommand(`Unsupported dump format: "${format}". Supported formats: csv, xlsx`);
+			failCommand(t("command.dump.errors.unsupportedFormat", { format }));
 			return;
 		}
 		const resolvedOutput = outputPathArg ? path.resolve(outputPathArg) : path.resolve(cwd, `${tableName}.${format}`);
 		if (!fs$1.existsSync(config.databasePath)) {
-			failCommand(`Database file not found at ${config.databasePath}. Please run "aiex schema" to create the database first.`);
+			failCommand(t("command.dump.errors.dbNotFound", {
+				path: config.databasePath,
+				cmd: "aiex schema"
+			}));
 			return;
 		}
 		const s = spinner();
-		s.start(`Loading data from table "${tableName}"...`);
+		s.start(t("command.dump.loading", { name: tableName }));
 		let columns = [];
 		let rows = [];
 		try {
@@ -14536,8 +14598,11 @@ const dumpCommand = defineCommand({
         select name from sqlite_master
         where type = 'table' and name = ?
       `).get(tableName)) {
-				s.stop("Database query failed");
-				failCommand(`Table "${tableName}" not found in database. Run "aiex schema" first to migrate.`);
+				s.stop(t("command.dump.dbQueryFailed"));
+				failCommand(t("command.dump.errors.tableNotFound", {
+					name: tableName,
+					cmd: "aiex schema"
+				}));
 				db.close();
 				return;
 			}
@@ -14545,16 +14610,16 @@ const dumpCommand = defineCommand({
 			rows = db.prepare(`select * from ${tableName}`).all();
 			db.close();
 		} catch (error) {
-			s.stop("Database query failed");
+			s.stop(t("command.dump.dbQueryFailed"));
 			failCommand(error instanceof Error ? error.message : String(error));
 			return;
 		}
 		if (rows.length === 0) {
-			s.stop("Empty table");
-			consola.warn(`Table "${tableName}" is empty. Exporting empty file...`);
-		} else s.stop(`Loaded ${rows.length} row(s)`);
+			s.stop(t("command.dump.emptyTable"));
+			consola.warn(t("command.dump.errors.tableEmpty", { name: tableName }));
+		} else s.stop(t("command.dump.loaded", { count: rows.length }));
 		const s2 = spinner();
-		s2.start("Formatting data...");
+		s2.start(t("command.dump.formatting"));
 		const formattedRows = rows.map((row) => {
 			const newRow = {};
 			columns.forEach((col) => {
@@ -14580,9 +14645,12 @@ const dumpCommand = defineCommand({
 			});
 			return newRow;
 		});
-		s2.stop("Data formatted");
+		s2.stop(t("command.dump.formatted"));
 		const s3 = spinner();
-		s3.start(`Writing ${format.toUpperCase()} file to ${resolvedOutput}...`);
+		s3.start(t("command.dump.writing", {
+			format: format.toUpperCase(),
+			path: resolvedOutput
+		}));
 		try {
 			const ws = XLSX.utils.json_to_sheet(formattedRows, { header: columns.map((col) => col.name) });
 			const outputDir = path.dirname(resolvedOutput);
@@ -14595,14 +14663,17 @@ const dumpCommand = defineCommand({
 				const csv = XLSX.utils.sheet_to_csv(ws);
 				fs$1.writeFileSync(resolvedOutput, "" + csv, "utf8");
 			}
-			s3.stop("Dump completed successfully");
-			consola.success(`Successfully dumped ${rows.length} row(s) to ${pc.cyan(resolvedOutput)}`);
+			s3.stop(t("command.dump.dumpCompleted"));
+			consola.success(t("command.dump.successMsg", {
+				count: rows.length,
+				path: pc.cyan(resolvedOutput)
+			}));
 		} catch (error) {
-			s3.stop("File write failed");
+			s3.stop(t("command.dump.fileWriteFailed"));
 			failCommand(error instanceof Error ? error.message : String(error));
 			return;
 		}
-		outro("Done!");
+		outro(t("common.done"));
 	}
 });
 
@@ -14628,15 +14699,15 @@ function formatSource(source) {
 async function loadConfiguredAI(aiexDir) {
 	const aiConfig = await readAIConfig(aiexDir);
 	if (!aiConfig) {
-		failCommand("AI configuration not found. Please run \"aiex web\" to configure AI settings first");
+		failCommand(t("command.extract.errors.noAIConfig", { cmd: "aiex web" }));
 		return null;
 	}
 	if (!aiConfig.provider.apiKey) {
-		failCommand("API Key not configured. Please configure AI settings in the Web interface first");
+		failCommand(t("command.extract.errors.noApiKey"));
 		return null;
 	}
 	if (!aiConfig.provider.models?.length) {
-		failCommand("No models configured. Please add at least one model in AI Settings");
+		failCommand(t("command.extract.errors.noModels"));
 		return null;
 	}
 	return aiConfig;
@@ -14645,7 +14716,10 @@ function resolveModelOverride(aiConfig, modelName) {
 	if (!modelName) return void 0;
 	const matched = aiConfig.provider.models.find((m) => m.name === modelName);
 	if (!matched) {
-		failCommand(`Model "${modelName}" not found in configuration. Available models: ${aiConfig.provider.models.map((m) => m.name).join(", ")}`);
+		failCommand(t("command.extract.errors.modelNotFound", {
+			model: modelName,
+			available: aiConfig.provider.models.map((m) => m.name).join(", ")
+		}));
 		return null;
 	}
 	return matched;
@@ -14653,13 +14727,13 @@ function resolveModelOverride(aiConfig, modelName) {
 const historyCommand = defineCommand({
 	meta: {
 		name: "history",
-		description: "List extraction audit records"
+		description: t("command.extract.history.description")
 	},
 	async run() {
 		const config = createMigrationConfig(process.cwd());
 		const records = await listExtractionAuditRecords(path.dirname(config.schemaPath));
 		if (records.length === 0) {
-			consola.info("No extraction history found");
+			consola.info(t("command.extract.history.empty"));
 			return;
 		}
 		for (const record of records) {
@@ -14671,22 +14745,22 @@ const historyCommand = defineCommand({
 const showCommand = defineCommand({
 	meta: {
 		name: "show",
-		description: "Show an extraction audit record"
+		description: t("command.extract.show.description")
 	},
 	args: { id: {
 		type: "string",
-		description: "Audit record id"
+		description: t("command.extract.show.args.id")
 	} },
 	async run({ args }) {
 		const id = getIdArg(args);
 		if (!id) {
-			failCommand("Audit record id is required");
+			failCommand(t("command.extract.history.errors.idRequired"));
 			return;
 		}
 		const config = createMigrationConfig(process.cwd());
 		const record = await readExtractionAuditRecord(path.dirname(config.schemaPath), id);
 		if (!record) {
-			failCommand(`Extraction record not found: ${id}`);
+			failCommand(t("command.extract.history.errors.recordNotFound", { id }));
 			return;
 		}
 		consola.info(JSON.stringify(record, null, 2));
@@ -14695,31 +14769,32 @@ const showCommand = defineCommand({
 const retryCommand = defineCommand({
 	meta: {
 		name: "retry",
-		description: "Retry an extraction audit record"
+		description: t("command.extract.retry.description")
 	},
 	args: {
 		id: {
 			type: "string",
-			description: "Audit record id"
+			description: t("command.extract.retry.args.id")
 		},
 		noInsert: {
 			type: "boolean",
-			description: "Extract and save JSON without inserting into SQLite",
+			description: t("command.extract.retry.args.noInsert"),
 			default: false
 		}
 	},
 	async run({ args }) {
 		intro(pc.inverse(" aiex extract retry "));
+		await initI18n();
 		const id = getIdArg(args);
 		if (!id) {
-			failCommand("Audit record id is required");
+			failCommand(t("command.extract.history.errors.idRequired"));
 			return;
 		}
 		const config = createMigrationConfig(process.cwd());
 		const aiexDir = path.dirname(config.schemaPath);
 		const record = await readExtractionAuditRecord(aiexDir, id);
 		if (!record) {
-			failCommand(`Extraction record not found: ${id}`);
+			failCommand(t("command.extract.history.errors.recordNotFound", { id }));
 			return;
 		}
 		const aiConfig = await loadConfiguredAI(aiexDir);
@@ -14742,7 +14817,7 @@ const retryCommand = defineCommand({
 				failCommand(result.error);
 				return;
 			}
-			outro("Done!");
+			outro(t("common.done"));
 		} catch (error) {
 			if (isMissingUploadFileError(error)) {
 				failCommand(MISSING_UPLOAD_FILE_TEXT);
@@ -14755,30 +14830,30 @@ const retryCommand = defineCommand({
 const rmCommand = defineCommand({
 	meta: {
 		name: "rm",
-		description: "Delete an extraction audit record and cached upload"
+		description: t("command.extract.rm.description")
 	},
 	args: { id: {
 		type: "string",
-		description: "Audit record id"
+		description: t("command.extract.rm.args.id")
 	} },
 	async run({ args }) {
 		const id = getIdArg(args);
 		if (!id) {
-			failCommand("Audit record id is required");
+			failCommand(t("command.extract.history.errors.idRequired"));
 			return;
 		}
 		const config = createMigrationConfig(process.cwd());
 		if (!await deleteExtractionAuditRecord(path.dirname(config.schemaPath), id)) {
-			failCommand(`Extraction record not found: ${id}`);
+			failCommand(t("command.extract.history.errors.recordNotFound", { id }));
 			return;
 		}
-		consola.success(`Deleted extraction record: ${id}`);
+		consola.success(t("command.extract.history.deleted", { id }));
 	}
 });
 const extractCommand = defineCommand({
 	meta: {
 		name: "extract",
-		description: "Extract structured data from text, images, or PDFs"
+		description: t("command.extract.description")
 	},
 	subCommands: {
 		history: historyCommand,
@@ -14790,46 +14865,47 @@ const extractCommand = defineCommand({
 		schema: {
 			type: "string",
 			alias: "s",
-			description: "Schema name (without .json extension)"
+			description: t("command.extract.args.schema")
 		},
 		file: {
 			type: "string",
 			alias: "f",
-			description: `File path to extract from. Supported: ${SUPPORTED_FILE_TYPES_TEXT}.`
+			description: t("command.extract.args.file", { types: SUPPORTED_FILE_TYPES_TEXT })
 		},
 		model: {
 			type: "string",
 			alias: "m",
-			description: "AI model to use for extraction (overrides auto-selection)"
+			description: t("command.extract.args.model")
 		},
 		dir: {
 			type: "string",
 			alias: "d",
-			description: "Directory containing files to batch extract"
+			description: t("command.extract.args.dir")
 		},
 		glob: {
 			type: "string",
 			alias: "g",
-			description: "Glob pattern to filter files in batch mode (e.g. \"*.pdf\")"
+			description: t("command.extract.args.glob")
 		},
 		noInsert: {
 			type: "boolean",
-			description: "Extract and save JSON without inserting into SQLite",
+			description: t("command.extract.args.noInsert"),
 			default: false
 		},
 		force: {
 			type: "boolean",
-			description: "Force re-extraction even if the file has already been processed successfully",
+			description: t("command.extract.args.force"),
 			default: false
 		}
 	},
 	async run({ args, rawArgs }) {
 		if (isExtractSubCommand(rawArgs)) return;
 		intro(pc.inverse(" aiex extract "));
+		await initI18n();
 		const config = createMigrationConfig(process.cwd());
 		const aiexDir = path.dirname(config.schemaPath);
 		if (args.dir && args.file) {
-			failCommand("Cannot combine -f/--file with -d/--dir");
+			failCommand(t("command.extract.errors.conflictFileDir"));
 			return;
 		}
 		const aiConfig = await loadConfiguredAI(aiexDir);
@@ -14837,12 +14913,12 @@ const extractCommand = defineCommand({
 		const modelOverride = resolveModelOverride(aiConfig, args.model);
 		if (modelOverride === null) return;
 		if (!args.schema && !args.file && !args.dir) {
-			if (await runInteractive(aiexDir, config, aiConfig, modelOverride)) outro("Done!");
+			if (await runInteractive(aiexDir, config, aiConfig, modelOverride)) outro(t("common.done"));
 			return;
 		}
 		if (args.dir) {
 			if (!args.schema) {
-				failCommand("Schema name (-s) is required in batch mode");
+				failCommand(t("command.extract.errors.schemaRequiredBatch"));
 				return;
 			}
 			const result$1 = await runBatchExtraction(aiexDir, config, aiConfig, args.schema, args.dir, args.glob, modelOverride, {
@@ -14854,16 +14930,16 @@ const extractCommand = defineCommand({
 				return;
 			}
 			if (result$1.failCount > 0) process.exitCode = 1;
-			if (result$1.failCount > 0) outro(`Completed with failures (${result$1.failCount} failed)`);
-			else outro("Done!");
+			if (result$1.failCount > 0) outro(t("command.extract.batch.failSummary", { count: result$1.failCount }));
+			else outro(t("common.done"));
 			return;
 		}
 		if (!args.schema) {
-			failCommand("Please provide a schema name (-s) to extract from");
+			failCommand(t("command.extract.errors.schemaRequiredSingle"));
 			return;
 		}
 		if (!args.file) {
-			failCommand("Please provide a file (-f) to extract from");
+			failCommand(t("command.extract.errors.fileRequiredSingle"));
 			return;
 		}
 		const result = await runAuditedExtraction({
@@ -14884,51 +14960,54 @@ const extractCommand = defineCommand({
 			failCommand(result.error);
 			return;
 		}
-		outro("Done!");
+		outro(t("common.done"));
 	}
 });
 async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 	const schemas = await listSchemas(aiexDir);
 	if (schemas.length === 0) {
-		failCommand(`No schema files found in ${pc.cyan(".aiex/schema/")}. Run ${pc.cyan("aiex web")} to create and configure schemas first.`);
+		failCommand(t("command.extract.errors.noSchemas", {
+			path: pc.cyan(".aiex/schema/"),
+			cmd: pc.cyan("aiex web")
+		}));
 		return false;
 	}
 	const schemaName = await select({
-		message: "Select a schema to extract data for:",
+		message: t("command.extract.interactive.selectSchema"),
 		options: schemas.map((s) => ({
 			label: s,
 			value: s
 		}))
 	});
 	if (isCancel(schemaName)) {
-		cancel("Cancelled");
+		cancel(t("common.cancelled"));
 		return false;
 	}
 	const inputSource = await select({
-		message: "Choose input source:",
+		message: t("command.extract.interactive.chooseSource"),
 		options: [{
-			label: "Single file",
+			label: t("command.extract.interactive.singleFile"),
 			value: "file",
-			hint: "Extract from a file (txt, pdf, image)"
+			hint: t("command.extract.interactive.singleFileHint")
 		}, {
-			label: "Batch directory",
+			label: t("command.extract.interactive.batchDir"),
 			value: "dir",
-			hint: "Extract all supported files in a directory"
+			hint: t("command.extract.interactive.batchDirHint")
 		}]
 	});
 	if (isCancel(inputSource)) {
-		cancel("Cancelled");
+		cancel(t("common.cancelled"));
 		return false;
 	}
 	if (inputSource === "file") {
 		const filePathStr = await text({
-			message: "Enter file path:",
+			message: t("command.extract.interactive.enterFilePath"),
 			validate(value) {
-				if (!value || value.trim().length === 0) return "Please enter a file path";
+				if (!value || value.trim().length === 0) return t("command.extract.interactive.filePathRequired");
 			}
 		});
 		if (isCancel(filePathStr)) {
-			cancel("Cancelled");
+			cancel(t("common.cancelled"));
 			return false;
 		}
 		return (await runAuditedExtraction({
@@ -14944,13 +15023,13 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 		})).success;
 	} else if (inputSource === "dir") {
 		const dirPath = await text({
-			message: "Enter directory path:",
+			message: t("command.extract.interactive.enterDirPath"),
 			validate(value) {
-				if (!value || value.trim().length === 0) return "Please enter a directory path";
+				if (!value || value.trim().length === 0) return t("command.extract.interactive.dirPathRequired");
 			}
 		});
 		if (isCancel(dirPath)) {
-			cancel("Cancelled");
+			cancel(t("common.cancelled"));
 			return false;
 		}
 		const result = await runBatchExtraction(aiexDir, config, aiConfig, schemaName, dirPath, void 0, modelOverride);
@@ -14961,7 +15040,7 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 }
 function cancel(msg) {
 	consola.info(msg);
-	outro("Cancelled");
+	outro(t("common.cancelled"));
 	process.exitCode = 0;
 }
 
@@ -15006,18 +15085,18 @@ function parseMigrationOutput(stdout, stderr) {
 		const jsonLine = stdout.trim().split("\n").find((l) => l.startsWith("{") && l.endsWith("}"));
 		if (!jsonLine) return {
 			success: false,
-			error: "Migration helper did not return valid output"
+			error: t("errors.schema.migrationHelperInvalidOutput")
 		};
 		const result = JSON.parse(jsonLine);
 		if (!result.success) return {
 			success: false,
-			error: result.error || "Migration failed"
+			error: result.error || t("errors.schema.migrationFailed")
 		};
 		return result;
 	} catch {
 		return {
 			success: false,
-			error: stderr || stdout || "Migration helper failed"
+			error: stderr || stdout || t("errors.schema.migrationHelperFailed")
 		};
 	}
 }
@@ -15046,7 +15125,7 @@ async function runSchemaSync(config, options = {}) {
 	const schemaFiles = await listSchemaFiles(config.schemaPath);
 	if (schemaFiles.length === 0) return {
 		success: false,
-		error: "No schema files found",
+		error: t("errors.schema.noFiles"),
 		warnings: [],
 		schemaCount: 0,
 		tables: 0,
@@ -15085,61 +15164,65 @@ async function runSchemaSync(config, options = {}) {
 const schemaCommand = defineCommand({
 	meta: {
 		name: "schema",
-		description: "Sync JSON Schema to SQLite database"
+		description: t("command.schema.description")
 	},
 	args: {
 		generate: {
 			type: "boolean",
 			alias: "g",
-			description: "Only generate Drizzle schema, skip migrate",
+			description: t("command.schema.args.generate"),
 			default: false
 		},
 		name: {
 			type: "string",
-			description: "Name for the migration"
+			description: t("command.schema.args.name")
 		}
 	},
 	async run({ args }) {
 		intro(pc.inverse(" aiex schema "));
+		await initI18n();
 		const config = createMigrationConfig(process.cwd());
 		const schemaFiles = await listSchemaFiles(config.schemaPath);
 		if (schemaFiles.length === 0) {
-			consola.info(`Run ${pc.cyan("aiex web")} to create and configure schemas in the Web UI`);
-			failCommand(`No schema files found in ${pc.cyan(".aiex/schema/")}`);
+			consola.info(t("command.schema.runWebHint", { cmd: pc.cyan("aiex web") }));
+			failCommand(t("command.schema.noSchemas", { path: pc.cyan(".aiex/schema/") }));
 			return;
 		}
 		const s1 = spinner();
-		s1.start("Generating Drizzle schema...");
+		s1.start(t("command.schema.generating"));
 		const generated = await generateSchemaFromFiles(schemaFiles, config);
 		for (const warning of generated.warnings) consola.warn(warning);
-		if (generated.success) consola.success(`Generated ${pc.cyan(".aiex/drizzle/schema.ts")} from ${generated.schemaCount} schema file(s)`);
+		if (generated.success) consola.success(t("command.schema.generated", {
+			path: pc.cyan(".aiex/drizzle/schema.ts"),
+			count: generated.schemaCount
+		}));
 		else if (generated.error) consola.error(generated.error);
-		s1.stop(generated.success ? "Schema generated" : "Generation failed");
+		s1.stop(generated.success ? t("command.schema.generatedOk") : t("command.schema.generatedFail"));
 		if (!generated.success) {
-			failCommand();
+			failCommand(t("common.failed"));
 			return;
 		}
 		if (args.generate) {
-			outro("Done! Run without --generate to apply migrations");
+			outro(t("command.schema.runWithoutGenerate"));
 			return;
 		}
 		const s2 = spinner();
-		s2.start("Running migrations...");
+		s2.start(t("command.schema.runningMigrations"));
 		const migration = await runSchemaMigration(config, args.name);
 		if (!migration.success) {
-			consola.error("Failed to generate migration");
-			consola.error(migration.error || "Migration failed");
-		} else if (migration.changes === 0) consola.info(pc.gray("No changes detected"));
+			consola.error(t("command.schema.migrationFailed"));
+			consola.error(migration.error || t("command.schema.migrationFail"));
+		} else if (migration.changes === 0) consola.info(pc.gray(t("command.schema.noChanges")));
 		else {
-			consola.success(pc.green("Migration files generated"));
-			consola.success(pc.green("Database migrated"));
+			consola.success(pc.green(t("command.schema.migrationFilesGenerated")));
+			consola.success(pc.green(t("command.schema.databaseMigrated")));
 		}
-		s2.stop(migration.success ? "Migrations applied" : "Migration failed");
+		s2.stop(migration.success ? t("command.schema.migrationsApplied") : t("command.schema.migrationFail"));
 		if (!migration.success) {
-			failCommand();
+			failCommand(t("common.failed"));
 			return;
 		}
-		outro("Done!");
+		outro(t("common.done"));
 	}
 });
 
@@ -15208,14 +15291,14 @@ var WatchRegistry = class {
 };
 async function notifySuccess(fileName) {
 	if (process.platform === "darwin") try {
-		await execa("osascript", ["-e", `display notification "Successfully processed and inserted data." with title "AIEX Watch: ${fileName}"`]);
+		await execa("osascript", ["-e", `display notification "${t("command.watch.notification.success")}" with title "${t("command.watch.notification.successTitle", { file: fileName })}"`]);
 		await execa("afplay", ["/System/Library/Sounds/Glass.aiff"]);
 	} catch {}
 	else process.stdout.write("\x07");
 }
 async function notifyFailure(fileName, errorMessage) {
 	if (process.platform === "darwin") try {
-		await execa("osascript", ["-e", `display notification "${errorMessage.replace(/"/g, "\\\"")}" with title "AIEX Watch Failed: ${fileName}"`]);
+		await execa("osascript", ["-e", `display notification "${errorMessage.replace(/"/g, "\\\"")}" with title "${t("command.watch.notification.failTitle", { file: fileName })}"`]);
 		await execa("afplay", ["/System/Library/Sounds/Basso.aiff"]);
 	} catch {}
 	else process.stdout.write("\x07\x07");
@@ -15227,9 +15310,9 @@ function startWatcher(options) {
 	const registry$2 = new WatchRegistry(aiexDir);
 	fs$1.mkdirSync(queueDirActive, { recursive: true });
 	fs$1.mkdirSync(queueDirFailed, { recursive: true });
-	consola.info(pc.green(`Starting watch on folder: ${pc.cyan(watchDir)}`));
-	consola.info(pc.green(`Schema: ${pc.cyan(schemaName)}`));
-	if (modelOverride) consola.info(pc.green(`Model Override: ${pc.cyan(modelOverride.name)}`));
+	consola.info(pc.green(t("command.watch.starting.watchFolder", { dir: pc.cyan(watchDir) })));
+	consola.info(pc.green(t("command.watch.starting.schema", { name: pc.cyan(schemaName) })));
+	if (modelOverride) consola.info(pc.green(t("command.watch.starting.modelOverride", { name: pc.cyan(modelOverride.name) })));
 	const watcher = chokidar.watch(watchDir, {
 		persistent: true,
 		ignoreInitial: false,
@@ -15245,15 +15328,18 @@ function startWatcher(options) {
 		if (!stat || !stat.isFile()) return;
 		const ext = path.extname(resolvedPath).toLowerCase().replace(".", "");
 		if (!SUPPORTED_EXTENSIONS.has(ext)) {
-			consola.warn(`[Watcher] Skipped unsupported file type: ${path.basename(resolvedPath)}`);
+			consola.warn(t("command.watch.events.skippedUnsupported", { file: path.basename(resolvedPath) }));
 			return;
 		}
 		const fileName = path.basename(resolvedPath);
-		consola.info(`[Watcher] New file detected: ${pc.cyan(fileName)}. Processing...`);
+		consola.info(t("command.watch.events.fileDetected", { file: pc.cyan(fileName) }));
 		try {
 			const hash = await getFileHash(resolvedPath);
 			if (await registry$2.getStatus(hash) === "succeeded") {
-				consola.info(`[Watcher] File ${pc.cyan(fileName)} (hash: ${hash.slice(0, 8)}) has already been processed successfully. Skipping.`);
+				consola.info(t("command.watch.events.alreadyProcessed", {
+					file: pc.cyan(fileName),
+					hash: hash.slice(0, 8)
+				}));
 				return;
 			}
 			const activeQueuePath = path.join(queueDirActive, `${hash}.${ext}`);
@@ -15262,25 +15348,28 @@ function startWatcher(options) {
 				await registry$2.markSucceeded(hash, resolvedPath);
 				await fs.rm(activeQueuePath, { force: true }).catch(() => {});
 				await fs.rm(activeQueuePath.replace(PDF_EXT_REGEXP, ".md"), { force: true }).catch(() => {});
-				consola.success(`[Watcher] File processed successfully: ${pc.green(fileName)}`);
+				consola.success(t("command.watch.events.processedSuccess", { file: pc.green(fileName) }));
 				await notifySuccess(fileName);
 			} else {
-				const errorMsg = "Extraction failed. See extraction audit history.";
+				const errorMsg = t("command.watch.events.extractionFailed");
 				await registry$2.markFailed(hash, resolvedPath, errorMsg);
 				const failedQueuePath = path.join(queueDirFailed, `${hash}-${Date.now()}.${ext}`);
 				await fs.rename(activeQueuePath, failedQueuePath).catch(() => {});
 				await fs.rm(activeQueuePath.replace(PDF_EXT_REGEXP, ".md"), { force: true }).catch(() => {});
-				consola.error(`[Watcher] Processing failed for: ${pc.red(fileName)}`);
+				consola.error(t("command.watch.events.processingFailed", { file: pc.red(fileName) }));
 				await notifyFailure(fileName, errorMsg);
 			}
 		} catch (e) {
 			const errorMsg = e instanceof Error ? e.message : String(e);
-			consola.error(`[Watcher] Error processing file ${fileName}: ${errorMsg}`);
+			consola.error(t("command.watch.events.errorProcessing", {
+				file: fileName,
+				error: errorMsg
+			}));
 			await notifyFailure(fileName, errorMsg);
 		}
 	});
 	watcher.on("error", (error) => {
-		consola.error(`[Watcher] Watcher error: ${error?.message || String(error)}`);
+		consola.error(t("command.watch.events.watcherError", { error: error?.message || String(error) }));
 	});
 	return watcher;
 }
@@ -15290,56 +15379,60 @@ function startWatcher(options) {
 const watchCommand = defineCommand({
 	meta: {
 		name: "watch",
-		description: "Watch a directory for new files and automatically extract data"
+		description: t("command.watch.description")
 	},
 	args: {
 		schema: {
 			type: "string",
 			alias: "s",
-			description: "Schema name (without .json extension) to use for extraction"
+			description: t("command.watch.args.schema")
 		},
 		dir: {
 			type: "string",
 			alias: "d",
-			description: "Directory path to watch for incoming files"
+			description: t("command.watch.args.dir")
 		},
 		model: {
 			type: "string",
 			alias: "m",
-			description: "AI model to use for extraction (overrides default/auto-selected model)"
+			description: t("command.watch.args.model")
 		},
 		noInsert: {
 			type: "boolean",
-			description: "Extract and save JSON without inserting into SQLite database",
+			description: t("command.watch.args.noInsert"),
 			default: false
 		}
 	},
 	async run({ args }) {
 		intro(pc.inverse(" aiex watch "));
+		await initI18n();
 		if (!args.schema) {
-			failCommand("Schema name (-s) is required");
+			failCommand(t("command.watch.errors.schemaRequired"));
 			return;
 		}
 		if (!args.dir) {
-			failCommand("Watch directory path (-d) is required");
+			failCommand(t("command.watch.errors.dirRequired"));
 			return;
 		}
 		const config = createMigrationConfig(process.cwd());
 		const aiexDir = path.dirname(config.schemaPath);
 		const schemaLoad = await loadSchema(config, args.schema);
 		if (!schemaLoad.schema) {
-			failCommand(schemaLoad.error || `Schema file for "${args.schema}" not found`);
+			failCommand(schemaLoad.error || t("command.watch.errors.schemaNotFound", { name: args.schema }));
 			return;
 		}
 		let watchDirStat;
 		try {
 			watchDirStat = fs$1.statSync(args.dir);
 		} catch (e) {
-			failCommand(`Watch directory does not exist: ${args.dir} — ${e instanceof Error ? e.message : String(e)}`);
+			failCommand(t("command.watch.errors.dirNotExist", {
+				dir: args.dir,
+				error: e instanceof Error ? e.message : String(e)
+			}));
 			return;
 		}
 		if (!watchDirStat.isDirectory()) {
-			failCommand(`Watch path is not a directory: ${args.dir}`);
+			failCommand(t("command.watch.errors.notADirectory", { dir: args.dir }));
 			return;
 		}
 		const watchDirAbs = path.resolve(args.dir);
@@ -15357,14 +15450,14 @@ const watchCommand = defineCommand({
 			insert: !args.noInsert
 		});
 		const cleanup = async () => {
-			consola.info("\nStopping watch directory daemon...");
+			consola.info(t("command.watch.events.stopped"));
 			await watcher.close();
-			consola.success("Daemon stopped.");
+			consola.success(t("command.watch.events.stoppedOk"));
 			process.exit(0);
 		};
 		process.on("SIGINT", cleanup);
 		process.on("SIGTERM", cleanup);
-		consola.info("Press Ctrl+C to stop");
+		consola.info(t("command.watch.events.pressCtrlC"));
 	}
 });
 
@@ -15430,7 +15523,7 @@ function aiRoutes(config) {
 			const schemaName = typeof body.schemaName === "string" ? body.schemaName : "";
 			if (!schemaName) return c.json({
 				success: false,
-				error: "Schema is required"
+				error: t("server.schemaRequired")
 			}, 400);
 			const result = await inspectNotionDatabase({
 				token,
@@ -15455,26 +15548,26 @@ function aiRoutes(config) {
 			const userTpl = body?.prompt?.userTemplate;
 			if (!systemTpl || !systemTpl.includes("{schema}")) return c.json({
 				success: false,
-				error: "System prompt must contain the {schema} placeholder"
+				error: t("server.promptSchemaPlaceholder")
 			}, 400);
 			if (!userTpl?.includes("{text}")) return c.json({
 				success: false,
-				error: "User prompt must contain the {text} placeholder"
+				error: t("server.promptTextPlaceholder")
 			}, 400);
 			if (!body.provider?.models?.length) return c.json({
 				success: false,
-				error: "At least one model must be configured"
+				error: t("server.atLeastOneModel")
 			}, 400);
 			if (body.notion?.enabled) {
 				if (!body.notion.token?.trim()) return c.json({
 					success: false,
-					error: "Notion token is required when Notion export is enabled"
+					error: t("server.notionTokenRequired")
 				}, 400);
 				for (const [schemaName, schemaConfig] of Object.entries(body.notion.schemas ?? {})) {
 					if (typeof schemaConfig.databaseId === "string") schemaConfig.databaseId = parseNotionDatabaseId(schemaConfig.databaseId);
 					if (!schemaConfig.databaseId?.trim()) return c.json({
 						success: false,
-						error: `Notion database ID is required for schema "${schemaName}"`
+						error: t("server.notionDbIdRequired", { name: schemaName })
 					}, 400);
 				}
 			}
@@ -15626,21 +15719,21 @@ function dataRoutes(config) {
 			return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
 		}
 	});
-	app.get("/data/tables/:name", zValidator("param", tableParamSchema, invalidParamResponse$1("Invalid table name")), zValidator("query", tableQuerySchema), async (c) => {
+	app.get("/data/tables/:name", zValidator("param", tableParamSchema, invalidParamResponse$1(t("server.invalidTableName"))), zValidator("query", tableQuerySchema), async (c) => {
 		const { name: tableName } = c.req.valid("param");
 		const { page, pageSize, search, sortField, sortOrder, all } = c.req.valid("query");
 		let db;
 		try {
 			db = createReadonlyQueryDb(config.databasePath);
 		} catch {
-			return c.json({ error: "Database not found. Run `aiex schema` first." }, 400);
+			return c.json({ error: t("server.dbNotFound") }, 400);
 		}
 		try {
 			if ((await sql`
           select name
           from sqlite_master
           where type = 'table' and name = ${tableName}
-        `.execute(db)).rows.length === 0) return c.json({ error: `Table "${tableName}" not found in database` }, 404);
+        `.execute(db)).rows.length === 0) return c.json({ error: t("server.tableNotFound", { name: tableName }) }, 404);
 			const columns = (await sql`
           pragma table_info(${sql.table(tableName)})
         `.execute(db)).rows.map((col) => ({
@@ -15708,7 +15801,7 @@ function dataRoutes(config) {
 			await db.destroy();
 		}
 	});
-	app.get("/data/:name", zValidator("param", extractionFileParamSchema, invalidParamResponse$1("Invalid extraction file name")), async (c) => {
+	app.get("/data/:name", zValidator("param", extractionFileParamSchema, invalidParamResponse$1(t("server.invalidFileName"))), async (c) => {
 		const { name: name$1 } = c.req.valid("param");
 		const filePath = path.join(extractedDir, name$1);
 		try {
@@ -15719,31 +15812,31 @@ function dataRoutes(config) {
 				name: name$1
 			});
 		} catch {
-			return c.json({ error: "Extraction result not found" }, 404);
+			return c.json({ error: t("server.extractionNotFound") }, 404);
 		}
 	});
-	app.post("/data/:name/notion/retry", zValidator("param", extractionFileParamSchema, invalidParamResponse$1("Invalid extraction file name")), async (c) => {
+	app.post("/data/:name/notion/retry", zValidator("param", extractionFileParamSchema, invalidParamResponse$1(t("server.invalidFileName"))), async (c) => {
 		const { name: name$1 } = c.req.valid("param");
 		const filePath = path.join(extractedDir, name$1);
 		const schemaName = schemaNameFromExtractionFile(name$1);
 		if (!schemaName) return c.json({
 			success: false,
-			error: "Cannot infer schema name from extraction file name"
+			error: t("server.cannotInferSchema")
 		}, 400);
 		const aiConfig = await readAIConfig(aiexDir);
 		if (!aiConfig?.notion?.enabled) return c.json({
 			success: false,
-			error: "Notion export is not enabled. Configure Notion settings first."
+			error: t("errors.notion.notEnabled")
 		}, 400);
 		if (!aiConfig.notion.schemas?.[schemaName]?.databaseId?.trim()) return c.json({
 			success: false,
-			error: `Notion database is not configured for schema "${schemaName}".`
+			error: t("errors.notion.noSchemaConfig", { name: schemaName })
 		}, 400);
 		try {
 			const data = await readFile(filePath);
 			if (!data || typeof data !== "object" || Array.isArray(data)) return c.json({
 				success: false,
-				error: "Extraction result is not a JSON object and cannot be written to Notion."
+				error: t("errors.ai.extractionNotObject")
 			}, 400);
 			const page = await writeNotionPage(aiConfig.notion, schemaName, data);
 			const notionPages = [{
@@ -15837,15 +15930,15 @@ function extractRoutes(config) {
 			const file = getFormFile(body.file);
 			if (!schemaName) return c.json({
 				success: false,
-				error: "Schema is required"
+				error: t("server.schemaRequired")
 			}, 400);
 			if (!text$1 && !file) return c.json({
 				success: false,
-				error: "Provide text or upload a file to extract"
+				error: t("server.provideTextOrFile")
 			}, 400);
 			if (text$1 && file) return c.json({
 				success: false,
-				error: "Text and file input cannot be used together"
+				error: t("server.conflictTextAndFile")
 			}, 400);
 			let source;
 			if (file) {
@@ -15871,20 +15964,20 @@ function extractRoutes(config) {
 			const aiConfig = await readAIConfig(aiexDir);
 			if (!aiConfig) return c.json({
 				success: false,
-				error: "AI configuration not found. Configure AI settings first."
+				error: t("server.aiConfigNotFound")
 			}, 400);
 			if (!aiConfig.provider.apiKey) return c.json({
 				success: false,
-				error: "API Key not configured. Configure AI settings first."
+				error: t("server.apiKeyNotConfigured")
 			}, 400);
 			if (!aiConfig.provider.models?.length) return c.json({
 				success: false,
-				error: "No models configured. Add at least one model in AI Settings."
+				error: t("server.noModelsConfigured")
 			}, 400);
 			const modelOverride = modelName ? aiConfig.provider.models.find((model) => model.name === modelName) : void 0;
 			if (modelName && !modelOverride) return c.json({
 				success: false,
-				error: `Model "${modelName}" not found in AI settings`
+				error: t("server.modelNotFound", { name: modelName })
 			}, 400);
 			const result = await runAuditedExtraction({
 				aiexDir,
@@ -15924,25 +16017,25 @@ function extractRoutes(config) {
 		const original = await readExtractionAuditRecord(aiexDir, c.req.param("id"));
 		if (!original) return c.json({
 			success: false,
-			error: "Extraction record not found"
+			error: t("server.extractionRecordNotFound")
 		}, 404);
 		const aiConfig = await readAIConfig(aiexDir);
 		if (!aiConfig) return c.json({
 			success: false,
-			error: "AI configuration not found. Configure AI settings first."
+			error: t("server.aiConfigNotFound")
 		}, 400);
 		if (!aiConfig.provider.apiKey) return c.json({
 			success: false,
-			error: "API Key not configured. Configure AI settings first."
+			error: t("server.apiKeyNotConfigured")
 		}, 400);
 		if (!aiConfig.provider.models?.length) return c.json({
 			success: false,
-			error: "No models configured. Add at least one model in AI Settings."
+			error: t("server.noModelsConfigured")
 		}, 400);
 		const modelOverride = original.modelName ? aiConfig.provider.models.find((m) => m.name === original.modelName) : void 0;
 		if (original.modelName && !modelOverride) return c.json({
 			success: false,
-			error: `Model "${original.modelName}" not found in AI settings`
+			error: t("server.modelNotFound", { name: original.modelName })
 		}, 400);
 		const source = original.source.type === "file" && original.source.filePath ? {
 			type: "file",
@@ -15981,7 +16074,7 @@ function extractRoutes(config) {
 		const id = c.req.param("id");
 		if (!await readExtractionAuditRecord(aiexDir, id)) return c.json({
 			success: false,
-			error: "Extraction record not found"
+			error: t("server.extractionRecordNotFound")
 		}, 404);
 		await deleteExtractionAuditRecord(aiexDir, id);
 		return c.json({ success: true });
@@ -16010,16 +16103,16 @@ function schemaRoutes(config) {
 		const jsonFiles = (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json"));
 		return c.json(jsonFiles);
 	});
-	app.get("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse("Invalid schema file name")), async (c) => {
+	app.get("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse(t("server.invalidTableName"))), async (c) => {
 		const { name: name$1 } = c.req.valid("param");
 		const filePath = path.join(schemaDir, name$1);
 		try {
 			return c.json(await readFile(filePath));
 		} catch {
-			return c.json({ error: "Schema not found" }, 404);
+			return c.json({ error: t("server.schemaNotFound") }, 404);
 		}
 	});
-	app.post("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse("Invalid schema file name")), async (c) => {
+	app.post("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse(t("server.invalidTableName"))), async (c) => {
 		const { name: name$1 } = c.req.valid("param");
 		const filePath = path.join(schemaDir, name$1);
 		try {
@@ -16035,10 +16128,10 @@ function schemaRoutes(config) {
 			} catch {}
 			return c.json({ success: true });
 		} catch {
-			return c.json({ error: "Failed to save schema" }, 500);
+			return c.json({ error: t("server.saveSchemaFailed") }, 500);
 		}
 	});
-	app.get("/prompt-snapshot/:name", zValidator("param", tableNameParamSchema, invalidParamResponse("Invalid table name")), async (c) => {
+	app.get("/prompt-snapshot/:name", zValidator("param", tableNameParamSchema, invalidParamResponse(t("server.invalidTableName"))), async (c) => {
 		const { name: name$1 } = c.req.valid("param");
 		const aiexDir = path.dirname(schemaDir);
 		const snapshotPath = path.join(aiexDir, "extracted", `${name$1}.prompt.md`);
@@ -16051,11 +16144,11 @@ function schemaRoutes(config) {
 		} catch {
 			return c.json({
 				success: false,
-				error: "Prompt snapshot not found. Save the schema first."
+				error: t("server.promptSnapshotNotAvailable")
 			}, 404);
 		}
 	});
-	app.delete("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse("Invalid schema file name")), async (c) => {
+	app.delete("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse(t("server.invalidTableName"))), async (c) => {
 		const { name: name$1 } = c.req.valid("param");
 		const filePath = path.join(schemaDir, name$1);
 		try {
@@ -16071,7 +16164,7 @@ function schemaRoutes(config) {
 			await fs.unlink(filePath);
 			return c.json({ success: true });
 		} catch {
-			return c.json({ error: "Failed to delete schema" }, 500);
+			return c.json({ error: t("server.deleteSchemaFailed") }, 500);
 		}
 	});
 	app.post("/migrate", async (c) => {
@@ -16082,7 +16175,7 @@ function schemaRoutes(config) {
 				const status = result.schemaCount === 0 ? 400 : 500;
 				return c.json({
 					success: false,
-					error: result.error || "Migration failed"
+					error: result.error || t("server.migrationFailed")
 				}, status);
 			}
 			return c.json({
@@ -16123,7 +16216,7 @@ function createApp(config, staticDir) {
 			html = await fs.readFile(`${staticDir}/index.html`, "utf-8");
 		} catch {
 			html = `<!DOCTYPE html>
-<html lang="zh-CN">
+<html lang="en">
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
@@ -16173,31 +16266,32 @@ async function startWebServer(input) {
 const webCommand = defineCommand({
 	meta: {
 		name: "web",
-		description: "Start visual JSON Schema editor"
+		description: t("command.web.description")
 	},
 	args: { port: {
 		type: "string",
 		alias: "p",
-		description: "Port to listen on",
+		description: t("command.web.args.port"),
 		default: "13000"
 	} },
 	async run({ args }) {
+		await initI18n();
 		intro(pc.inverse(" aiex web "));
 		const cwd = process.cwd();
 		const port = Number(args.port) || 13e3;
 		const config = createMigrationConfig(cwd);
 		const s = spinner();
-		s.start("Starting web server...");
+		s.start(t("command.web.starting"));
 		await startWebServer({
 			config,
 			port,
 			onStarted(info) {
-				s.stop(`Server running at ${pc.cyan(info.url)}`);
-				consola.info(`Schema directory: ${pc.dim(info.schemaPath)}`);
-				consola.info("Press Ctrl+C to stop");
+				s.stop(t("command.web.serverRunning", { url: pc.cyan(info.url) }));
+				consola.info(t("command.web.schemaDir", { path: pc.dim(info.schemaPath) }));
+				consola.info(t("command.web.pressCtrlC"));
 			},
 			onOpenFailed(url) {
-				consola.warn(`Could not open browser. Visit ${url} manually.`);
+				consola.warn(t("command.web.browserOpenFailed", { url }));
 			}
 		});
 	}
@@ -16217,6 +16311,7 @@ const subCommands = {
 
 //#endregion
 //#region src/cli.ts
+await initI18n();
 seedConfig(createConfig());
 updateNotifier({ pkg: package_default }).notify();
 process.on("uncaughtException", (error) => {
@@ -16229,7 +16324,7 @@ process.on("unhandledRejection", (reason) => {
 	process.exit(1);
 });
 if (process.argv[2] === "_complete") {
-	const { getCompletions } = await import("./completions-C3rmTwXZ.mjs");
+	const { getCompletions } = await import("./completions-Bh0DOngr.mjs");
 	const suggestions = getCompletions(subCommands, process.argv.slice(4));
 	for (const s of suggestions) process.stdout.write(`${s}\n`);
 	process.exit(0);