aiex-cli 0.0.3 → 0.0.4-beta.2

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-CDg_BdI8.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -15,20 +15,20 @@ import fs$1 from "node:fs";
 import { intro, isCancel, outro, select, spinner, text } from "@clack/prompts";
 import Database from "better-sqlite3";
 import pc from "picocolors";
+import { Buffer } from "node:buffer";
 import * as XLSX from "xlsx";
-import { glob, globSync } from "tinyglobby";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { LangfuseSpanProcessor } from "@langfuse/otel";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { APICallError, Output, generateText, jsonSchema } from "ai";
-import mime from "mime";
 import pRetry from "p-retry";
+import mime from "mime";
 import { jsonrepair } from "jsonrepair";
+import { LangfuseSpanProcessor } from "@langfuse/otel";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import crypto from "node:crypto";
 import { Client, extractNotionId } from "@notionhq/client";
-import { Buffer } from "node:buffer";
 import { execa } from "execa";
+import { glob, globSync } from "tinyglobby";
 import { extractText, getDocumentProxy, getMeta } from "unpdf";
-import crypto from "node:crypto";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import * as chokidar from "chokidar";
@@ -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,10 +211,54 @@ 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;
 }
 
+//#endregion
+//#region src/core/export-manager.ts
+function formatRowsConformingToSchema(rows, columns, schema, format) {
+	return rows.map((row) => {
+		const newRow = {};
+		columns.forEach((col) => {
+			const colName = col.name;
+			const val = row[colName];
+			const type = (schema?.properties?.[colName])?.type || "";
+			if (val === null || val === void 0) newRow[colName] = "";
+			else if (type === "boolean") if (format === "xlsx") newRow[colName] = val === 1 || val === "1" || val === true;
+			else newRow[colName] = val === 1 || val === "1" || val === true ? "true" : "false";
+			else if (type === "number" || type === "integer") if (val === "") newRow[colName] = "";
+			else {
+				const num = Number(val);
+				newRow[colName] = Number.isNaN(num) ? val : num;
+			}
+			else if (typeof val === "object") newRow[colName] = JSON.stringify(val);
+			else {
+				const dbType = (col.type || "").toLowerCase();
+				if ((dbType.includes("int") || dbType.includes("real") || dbType.includes("num") || dbType.includes("double") || dbType.includes("float")) && typeof val === "string" && val !== "") {
+					const num = Number(val);
+					newRow[colName] = Number.isNaN(num) ? val : num;
+				} else newRow[colName] = val;
+			}
+		});
+		return newRow;
+	});
+}
+function generateExportBuffer(tableName, formattedRows, columns, format) {
+	const ws = XLSX.utils.json_to_sheet(formattedRows, { header: columns.map((col) => col.name) });
+	if (format === "xlsx") {
+		const wb = XLSX.utils.book_new();
+		XLSX.utils.book_append_sheet(wb, ws, tableName.slice(0, 31));
+		return XLSX.write(wb, {
+			bookType: "xlsx",
+			type: "buffer"
+		});
+	} else {
+		const csv = XLSX.utils.sheet_to_csv(ws);
+		return Buffer.from("" + csv, "utf8");
+	}
+}
+
 //#endregion
 //#region src/core/ai-extraction/model-capabilities.json
 var model_capabilities_default = {
@@ -12814,6 +12858,28 @@ async function withRetry(fn, onRetry, maxRetries = 5) {
 	});
 }
 
+//#endregion
+//#region src/core/ai-extraction/file-utils.ts
+function detectMimeType(filePath) {
+	return mime.getType(filePath) ?? "application/octet-stream";
+}
+async function readFilePart(filePath) {
+	const mimeStr = detectMimeType(filePath);
+	const buffer = await fs.readFile(filePath);
+	const name$1 = path.basename(filePath);
+	if (mimeStr.startsWith("image/")) return {
+		type: "image",
+		image: buffer,
+		mimeType: mimeStr
+	};
+	return {
+		type: "file",
+		data: buffer,
+		mediaType: mimeStr,
+		filename: name$1
+	};
+}
+
 //#endregion
 //#region src/core/ai-extraction/json-utils.ts
 function parseJsonLike(text$1) {
@@ -12875,15 +12941,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,
@@ -12990,7 +13059,34 @@ function generatePromptSnapshot(schema, promptConfig = DEFAULT_PROMPT_CONFIG) {
 }
 
 //#endregion
-//#region src/core/ai-extraction/extractor.ts
+//#region src/core/ai-extraction/snapshot.ts
+const SYSTEM_PROMPT_REGEX = /## System Prompt\n([\s\S]*?)(?=## User Prompt|$)/;
+const USER_PROMPT_REGEX = /## User Prompt Template\n([\s\S]*)$/;
+async function loadPromptSnapshot(aiexDir, tableName) {
+	const snapshotPath = path.join(aiexDir, "extracted", `${tableName}.prompt.md`);
+	try {
+		const content = await fs.readFile(snapshotPath, "utf-8");
+		const systemMatch = content.match(SYSTEM_PROMPT_REGEX);
+		const userMatch = content.match(USER_PROMPT_REGEX);
+		if (systemMatch && userMatch) return {
+			system: systemMatch[1].trim(),
+			user: userMatch[1].trim()
+		};
+	} catch {}
+	return null;
+}
+async function savePromptSnapshot(schema, aiexDir) {
+	const content = generatePromptSnapshot(schema, (await readAIConfig(aiexDir))?.prompt ?? DEFAULT_PROMPT_CONFIG);
+	const outputDir = path.join(aiexDir, "extracted");
+	await fs.mkdir(outputDir, { recursive: true });
+	const fileName = `${schema.table.name}.prompt.md`;
+	const outputPath = path.join(outputDir, fileName);
+	await fs.writeFile(outputPath, content);
+	return outputPath;
+}
+
+//#endregion
+//#region src/core/ai-extraction/telemetry.ts
 let langfuseInitialized = false;
 function initLangfuse(config) {
 	if (!config.langfuse?.publicKey || !config.langfuse.secretKey) return;
@@ -13007,28 +13103,9 @@ function initLangfuse(config) {
 		console.warn("[Langfuse] Failed to initialize tracing:", e instanceof Error ? e.message : e);
 	}
 }
-const SYSTEM_PROMPT_REGEX = /## System Prompt\n([\s\S]*?)(?=## User Prompt|$)/;
-const USER_PROMPT_REGEX = /## User Prompt Template\n([\s\S]*)$/;
-const OPENAI_COMPATIBLE_PROVIDER_NAME = "openai-compatible";
-function detectMimeType(filePath) {
-	return mime.getType(filePath) ?? "application/octet-stream";
-}
-async function readFilePart(filePath) {
-	const mime$1 = detectMimeType(filePath);
-	const buffer = await fs.readFile(filePath);
-	const name$1 = path.basename(filePath);
-	if (mime$1.startsWith("image/")) return {
-		type: "image",
-		image: buffer,
-		mimeType: mime$1
-	};
-	return {
-		type: "file",
-		data: buffer,
-		mediaType: mime$1,
-		filename: name$1
-	};
-}
+
+//#endregion
+//#region src/core/ai-extraction/validator.ts
 function nullableType(type) {
 	return type === "null" ? ["null"] : [type, "null"];
 }
@@ -13123,24 +13200,15 @@ function validateExtractedData(schema, data) {
 	};
 	return { success: true };
 }
-async function loadPromptSnapshot(aiexDir, tableName) {
-	const snapshotPath = path.join(aiexDir, "extracted", `${tableName}.prompt.md`);
-	try {
-		const content = await fs.readFile(snapshotPath, "utf-8");
-		const systemMatch = content.match(SYSTEM_PROMPT_REGEX);
-		const userMatch = content.match(USER_PROMPT_REGEX);
-		if (systemMatch && userMatch) return {
-			system: systemMatch[1].trim(),
-			user: userMatch[1].trim()
-		};
-	} catch {}
-	return null;
-}
+
+//#endregion
+//#region src/core/ai-extraction/extractor.ts
+const OPENAI_COMPATIBLE_PROVIDER_NAME = "openai-compatible";
 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/");
@@ -13185,66 +13253,118 @@ async function extractStructuredData(input) {
 			user = generated.user;
 		}
 		const outputSchema = jsonSchema(schemaToExtractionOutputSchema(schema));
-		let result;
 		const timeoutMs = (config.provider.timeout ?? 300) * 1e3;
-		if (useFileContent) {
-			const filePart = await readFilePart(file);
-			const fileName = filePart.type === "file" ? filePart.filename : path.basename(file);
-			const contentParts = [{
-				type: "text",
-				text: user.includes(PLACEHOLDER_TEXT) ? user.replaceAll(PLACEHOLDER_TEXT, text$1 || `Data is contained in the attached file: ${fileName}`) : user
-			}, filePart];
-			const fileOpts = {
-				model: provider.chatModel(selected.name),
-				system,
-				messages: [{
-					role: "user",
-					content: contentParts
-				}],
-				abortSignal: AbortSignal.timeout(timeoutMs),
-				maxRetries: 0,
-				experimental_telemetry: { isEnabled: useTelemetry }
-			};
-			if (useStructuredOutput) fileOpts.output = Output.object({ schema: outputSchema });
-			result = await withRetry(() => generateText(fileOpts), input.onRetry);
-		} else {
-			const textOpts = {
-				model: provider.chatModel(selected.name),
-				system,
-				prompt: user,
-				abortSignal: AbortSignal.timeout(timeoutMs),
-				maxRetries: 0,
-				experimental_telemetry: { isEnabled: useTelemetry }
-			};
-			if (useStructuredOutput) textOpts.output = Output.object({ schema: outputSchema });
-			result = await withRetry(() => generateText(textOpts), input.onRetry);
+		let systemPrompt = system;
+		let userPrompt = user;
+		const maxAttempts = 3;
+		let lastError = "";
+		let totalPromptTokens = 0;
+		let totalCompletionTokens = 0;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			let result = null;
+			let data;
+			let parseError;
+			let validationError;
+			try {
+				if (useFileContent) {
+					const filePart = await readFilePart(file);
+					const fileName = filePart.type === "file" ? filePart.filename : path.basename(file);
+					const contentParts = [{
+						type: "text",
+						text: userPrompt.includes(PLACEHOLDER_TEXT) ? userPrompt.replaceAll(PLACEHOLDER_TEXT, text$1 || `Data is contained in the attached file: ${fileName}`) : userPrompt
+					}, filePart];
+					const fileOpts = {
+						model: provider.chatModel(selected.name),
+						system: systemPrompt,
+						messages: [{
+							role: "user",
+							content: contentParts
+						}],
+						abortSignal: AbortSignal.timeout(timeoutMs),
+						maxRetries: 0,
+						experimental_telemetry: { isEnabled: useTelemetry }
+					};
+					if (useStructuredOutput) fileOpts.output = Output.object({ schema: outputSchema });
+					result = await withRetry(() => generateText(fileOpts), input.onRetry);
+				} else {
+					const textOpts = {
+						model: provider.chatModel(selected.name),
+						system: systemPrompt,
+						prompt: userPrompt,
+						abortSignal: AbortSignal.timeout(timeoutMs),
+						maxRetries: 0,
+						experimental_telemetry: { isEnabled: useTelemetry }
+					};
+					if (useStructuredOutput) textOpts.output = Output.object({ schema: outputSchema });
+					result = await withRetry(() => generateText(textOpts), input.onRetry);
+				}
+				if (result.usage) {
+					totalPromptTokens += result.usage.inputTokens ?? 0;
+					totalCompletionTokens += result.usage.outputTokens ?? 0;
+				}
+				if (useStructuredOutput) data = result.output;
+				else try {
+					data = safeParseJSON(result.text);
+				} catch (e) {
+					parseError = e instanceof Error ? e.message : String(e);
+				}
+			} catch (error) {
+				parseError = getErrorMessage(error);
+			}
+			if (!parseError && data !== void 0) {
+				const validation = validateExtractedData(schema, data);
+				if (validation.success) {
+					const outputDir = path.resolve(aiexDir, config.extraction.outputDir.replace(".aiex/", ""));
+					await fs.mkdir(outputDir, { recursive: true });
+					const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+					const outputFileName = `${schema.table.name}-${timestamp}.json`;
+					const outputPath = path.join(outputDir, outputFileName);
+					await writeFile(outputPath, data, {
+						spaces: 2,
+						EOL: "\n"
+					});
+					return {
+						success: true,
+						outputPath,
+						data,
+						tokensUsed: {
+							prompt: totalPromptTokens,
+							completion: totalCompletionTokens,
+							total: totalPromptTokens + totalCompletionTokens
+						}
+					};
+				} else validationError = validation.error;
+			}
+			const errorMsg = parseError || validationError || "Unknown validation error";
+			lastError = errorMsg;
+			if (attempt < maxAttempts) {
+				const invalidJson = data !== void 0 ? JSON.stringify(data, null, 2) : result ? result.text : "";
+				systemPrompt = `You are a precise data correction assistant. Your task is to correct validation errors in a previously generated JSON object to make it comply with the provided JSON Schema.
+        
+CRITICAL RULES:
+1. Only correct the fields that failed validation.
+2. Preserve all other correctly extracted fields and their values exactly.
+3. Return ONLY the corrected JSON object. No explanations, no markdown blocks other than JSON.`;
+				userPrompt = `The JSON data you generated previously failed validation. Please correct it.
+
+[Original Text]
+${text$1 || "Data is contained in the attached file."}
+
+[JSON Schema Definition]
+${JSON.stringify(schemaToExtractionOutputSchema(schema), null, 2)}
+
+[Previously Generated Invalid JSON]
+${invalidJson}
+
+[Validation Error Details]
+${errorMsg}
+
+Please output the corrected JSON object now:`;
+			}
 		}
-		let data;
-		if (useStructuredOutput) data = result.output;
-		else data = safeParseJSON(result.text);
-		const validation = validateExtractedData(schema, data);
-		if (!validation.success) return {
-			success: false,
-			error: validation.error
-		};
-		const outputDir = path.resolve(aiexDir, config.extraction.outputDir.replace(".aiex/", ""));
-		await fs.mkdir(outputDir, { recursive: true });
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-		const outputFileName = `${schema.table.name}-${timestamp}.json`;
-		const outputPath = path.join(outputDir, outputFileName);
-		await writeFile(outputPath, data, {
-			spaces: 2,
-			EOL: "\n"
-		});
 		return {
-			success: true,
-			outputPath,
-			data,
-			tokensUsed: result.usage ? {
-				prompt: result.usage.inputTokens ?? 0,
-				completion: result.usage.outputTokens ?? 0,
-				total: (result.usage.inputTokens ?? 0) + (result.usage.outputTokens ?? 0)
-			} : void 0
+			success: false,
+			error: lastError || "Extraction failed after self-reflection retries"
 		};
 	} catch (error) {
 		return {
@@ -13345,7 +13465,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({
@@ -13391,18 +13511,6 @@ function insertExtractedData(db, schema, data) {
 	}
 }
 
-//#endregion
-//#region src/core/ai-extraction/snapshot.ts
-async function savePromptSnapshot(schema, aiexDir) {
-	const content = generatePromptSnapshot(schema, (await readAIConfig(aiexDir))?.prompt ?? DEFAULT_PROMPT_CONFIG);
-	const outputDir = path.join(aiexDir, "extracted");
-	await fs.mkdir(outputDir, { recursive: true });
-	const fileName = `${schema.table.name}.prompt.md`;
-	const outputPath = path.join(outputDir, fileName);
-	await fs.writeFile(outputPath, content);
-	return outputPath;
-}
-
 //#endregion
 //#region src/core/extraction-audit.ts
 const AUDIT_ID_RE = /^[\w.-]+$/;
@@ -13440,7 +13548,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 +13581,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, {
@@ -13539,70 +13647,18 @@ async function findSucceededAuditByHash(aiexDir, schemaName, fileHash) {
 }
 
 //#endregion
-//#region src/core/file-constants.ts
-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 SUPPORTED_MIME_TYPES = new Set([
-	"image/png",
-	"image/jpeg",
-	"image/gif",
-	"image/webp",
-	"image/bmp",
-	"image/svg+xml",
-	"application/pdf",
-	"text/plain",
-	"text/markdown",
-	"text/csv",
-	"application/json",
-	"text/html",
-	"text/xml",
-	"application/x-yaml",
-	"text/yaml"
-]);
-const MIME_TO_EXT = {
-	"image/png": "png",
-	"image/jpeg": "jpg",
-	"image/gif": "gif",
-	"image/webp": "webp",
-	"image/bmp": "bmp",
-	"image/svg+xml": "svg",
-	"application/pdf": "pdf",
-	"text/plain": "txt",
-	"text/markdown": "md",
-	"text/csv": "csv",
-	"application/json": "json",
-	"text/html": "html",
-	"text/xml": "xml",
-	"application/x-yaml": "yaml",
-	"text/yaml": "yaml"
-};
-function bytesToMB(bytes) {
-	return bytes / (1024 * 1024);
-}
-function getExtensionFromMime(mimeType) {
-	return MIME_TO_EXT[mimeType];
-}
-function isAllowedMimeType(mimeType) {
-	return SUPPORTED_MIME_TYPES.has(mimeType);
-}
-function unsupportedFileTypeMessage(mimeType) {
-	return `Unsupported file type "${mimeType}". Supported: ${SUPPORTED_FILE_TYPES_TEXT}.`;
-}
-function isMissingUploadFileError(error) {
-	return !!error && typeof error === "object" && error.code === "ENOENT";
-}
-var FileValidationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "FileValidationError";
-	}
-};
-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 (!isAllowedMimeType(file.type)) throw new FileValidationError(unsupportedFileTypeMessage(file.type));
+//#region src/utils/hash.ts
+/**
+* Helper to compute SHA-256 hash of a file asynchronously.
+*/
+function getFileHash(filePath) {
+	return new Promise((resolve, reject) => {
+		const hash = crypto.createHash("sha256");
+		const stream = fs$1.createReadStream(filePath);
+		stream.on("data", (data) => hash.update(data));
+		stream.on("end", () => resolve(hash.digest("hex")));
+		stream.on("error", (err) => reject(err));
+	});
 }
 
 //#endregion
@@ -13756,7 +13812,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 +13824,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 +13835,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 +13853,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 +13862,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 +13881,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,
@@ -13837,27 +13893,155 @@ async function writeNotionPage(config, schemaName, data) {
 }
 
 //#endregion
-//#region src/core/pdf-converter/external.ts
-function applyTemplate(value, context) {
-	return value.replaceAll("{input}", context.input).replaceAll("{outputDir}", context.outputDir).replaceAll("{basename}", context.basename);
+//#region src/core/webhook-sink.ts
+async function sendWebhook(config, payload) {
+	if (!config || !config.enabled || !config.url) return;
+	const body = JSON.stringify(payload);
+	const headers = {
+		"Content-Type": "application/json",
+		"User-Agent": "aiex-webhook-dispatcher"
+	};
+	if (config.secret) headers["X-Aiex-Signature"] = `sha256=${crypto.createHmac("sha256", config.secret).update(body).digest("hex")}`;
+	const response = await fetch(config.url, {
+		method: "POST",
+		headers,
+		body
+	});
+	if (!response.ok) throw new Error(`Webhook request failed with status: ${response.status} ${response.statusText}`);
 }
-function isError(error) {
-	return error instanceof Error;
+
+//#endregion
+//#region src/core/integration/dispatcher.ts
+async function syncResultToNotion(aiConfig, schemaName, data) {
+	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,
+		pageId: page.pageId
+	}];
 }
-async function pathExists(filePath) {
+function shouldSyncNotion(aiConfig, schemaName) {
+	return !!aiConfig.notion?.enabled && !!aiConfig.notion.schemas?.[schemaName]?.databaseId?.trim();
+}
+async function triggerWebhook(aiConfig, auditId, schemaName, event, source, data, error, tokensUsed, quiet = false) {
+	if (!aiConfig.webhook?.enabled) return;
 	try {
-		await fs.access(filePath);
-		return true;
-	} catch {
-		return false;
+		await sendWebhook(aiConfig.webhook, {
+			event,
+			schemaName,
+			auditId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			source: {
+				type: source.type,
+				fileName: source.filePath ? path.basename(source.filePath) : void 0,
+				filePath: source.filePath
+			},
+			data,
+			error,
+			tokensUsed
+		});
+		if (!quiet) consola.success(t("extract.file.webhookSynced"));
+	} catch (err) {
+		if (!quiet) consola.error(t("extract.file.webhookSyncFail", { error: err instanceof Error ? err.message : String(err) }));
 	}
 }
-async function collectMarkdownFiles(dir) {
-	return (await glob("**/*.md", {
-		cwd: dir,
-		absolute: true,
-		onlyFiles: true
-	})).sort();
+
+//#endregion
+//#region src/core/file-constants.ts
+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 = t("errors.file.missingUpload");
+const SUPPORTED_MIME_TYPES = new Set([
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp",
+	"image/bmp",
+	"image/svg+xml",
+	"application/pdf",
+	"text/plain",
+	"text/markdown",
+	"text/csv",
+	"application/json",
+	"text/html",
+	"text/xml",
+	"application/x-yaml",
+	"text/yaml"
+]);
+const MIME_TO_EXT = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/gif": "gif",
+	"image/webp": "webp",
+	"image/bmp": "bmp",
+	"image/svg+xml": "svg",
+	"application/pdf": "pdf",
+	"text/plain": "txt",
+	"text/markdown": "md",
+	"text/csv": "csv",
+	"application/json": "json",
+	"text/html": "html",
+	"text/xml": "xml",
+	"application/x-yaml": "yaml",
+	"text/yaml": "yaml"
+};
+function bytesToMB(bytes) {
+	return bytes / (1024 * 1024);
+}
+function getExtensionFromMime(mimeType) {
+	return MIME_TO_EXT[mimeType];
+}
+function isAllowedMimeType(mimeType) {
+	return SUPPORTED_MIME_TYPES.has(mimeType);
+}
+function unsupportedFileTypeMessage(mimeType) {
+	return t("errors.file.unsupportedType", {
+		type: mimeType,
+		supported: SUPPORTED_FILE_TYPES_TEXT
+	});
+}
+function isMissingUploadFileError(error) {
+	return !!error && typeof error === "object" && error.code === "ENOENT";
+}
+var FileValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FileValidationError";
+	}
+};
+function validateFileUpload(file) {
+	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));
+}
+
+//#endregion
+//#region src/core/pdf-converter/external.ts
+function applyTemplate(value, context) {
+	return value.replaceAll("{input}", context.input).replaceAll("{outputDir}", context.outputDir).replaceAll("{basename}", context.basename);
+}
+function isError(error) {
+	return error instanceof Error;
+}
+async function pathExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function collectMarkdownFiles(dir) {
+	return (await glob("**/*.md", {
+		cwd: dir,
+		absolute: true,
+		onlyFiles: true
+	})).sort();
 }
 async function selectMarkdownFile(outputDir, basename) {
 	const files = await collectMarkdownFiles(outputDir);
@@ -13962,7 +14146,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 +14181,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);
 	}
@@ -14009,22 +14196,7 @@ function createPdfConverter(config) {
 }
 
 //#endregion
-//#region src/utils/hash.ts
-/**
-* Helper to compute SHA-256 hash of a file asynchronously.
-*/
-function getFileHash(filePath) {
-	return new Promise((resolve, reject) => {
-		const hash = crypto.createHash("sha256");
-		const stream = fs$1.createReadStream(filePath);
-		stream.on("data", (data) => hash.update(data));
-		stream.on("end", () => resolve(hash.digest("hex")));
-		stream.on("error", (err) => reject(err));
-	});
-}
-
-//#endregion
-//#region src/core/extract-runner.ts
+//#region src/core/pdf-converter/orchestrator.ts
 const FILE_PART_EXTENSIONS = new Set([
 	"png",
 	"jpg",
@@ -14034,6 +14206,51 @@ const FILE_PART_EXTENSIONS = new Set([
 	"bmp",
 	"svg"
 ]);
+const PDF_EXT_RE = /\.pdf$/i;
+async function readExtractFileInput(filePath, aiConfig, modelOverride) {
+	const stat = fs$1.statSync(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(t("extract.file.ocrText", { confidence: (result.confidence * 100).toFixed(1) }));
+			return { text: result.text };
+		}
+		return {
+			text: "",
+			filePath
+		};
+	}
+	if (ext === "pdf") {
+		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(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(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(t("extract.file.markdownSaved", { path: fallbackMd }));
+		}
+		return { text: result.text };
+	}
+	return { text: await fs.readFile(filePath, "utf-8") };
+}
+
+//#endregion
+//#region src/core/batch/batch-processor.ts
 const SUPPORTED_EXTENSIONS$1 = new Set([
 	...FILE_PART_EXTENSIONS,
 	"pdf",
@@ -14046,50 +14263,114 @@ const SUPPORTED_EXTENSIONS$1 = new Set([
 	"yaml",
 	"yml"
 ]);
-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.");
-	const page = await writeNotionPage(aiConfig.notion, schemaName, data);
-	return [{
-		databaseId: page.databaseId,
-		pageId: page.pageId
-	}];
+function listSupportedFiles(dir, pattern) {
+	if (!fs$1.statSync(dir).isDirectory()) throw new Error(t("errors.file.notADirectory", { dir }));
+	return globSync(pattern ?? SUPPORTED_FILE_PATTERN, {
+		cwd: dir,
+		absolute: true,
+		onlyFiles: true
+	}).filter((file) => {
+		const ext = path.extname(file).toLowerCase().replace(".", "");
+		return SUPPORTED_EXTENSIONS$1.has(ext);
+	}).sort();
 }
-function shouldSyncNotion(aiConfig, schemaName) {
-	return !!aiConfig.notion?.enabled && !!aiConfig.notion.schemas?.[schemaName]?.databaseId?.trim();
+async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, modelOverride, options) {
+	const result = await runAuditedExtraction({
+		aiexDir,
+		config,
+		aiConfig,
+		schemaName,
+		source: {
+			type: "file",
+			filePath
+		},
+		modelOverride,
+		insert: options?.insert,
+		force: options?.force,
+		quiet: false
+	});
+	if (result.success) {
+		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(t("extract.batch.scanning", { dir: pc.cyan(dir) }));
+	let files;
+	try {
+		files = listSupportedFiles(dir, globPattern);
+	} catch {
+		return {
+			ok: false,
+			successCount: 0,
+			failCount: 0,
+			error: t("extract.batch.errors.cannotReadDir", { dir })
+		};
+	}
+	if (files.length === 0) return {
+		ok: false,
+		successCount: 0,
+		failCount: 0,
+		error: t("extract.batch.errors.noSupportedFiles", { dir })
+	};
+	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${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(`\n${t("extract.batch.complete", {
+		success: pc.green(successCount),
+		fail: pc.red(failCount),
+		total: files.length
+	})}`);
+	return {
+		ok: true,
+		successCount,
+		failCount
+	};
 }
+
+//#endregion
+//#region src/core/extract-runner.ts
+const JSON_EXT_RE$1 = /\.json$/;
 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}`);
-	return globSync(pattern ?? SUPPORTED_FILE_PATTERN, {
-		cwd: dir,
-		absolute: true,
-		onlyFiles: true
-	}).filter((file) => {
-		const ext = path.extname(file).toLowerCase().replace(".", "");
-		return SUPPORTED_EXTENSIONS$1.has(ext);
-	}).sort();
-}
 async function loadSchema(config, schemaName) {
 	const schemaPath = path.join(config.schemaPath, `${schemaName}.json`);
 	try {
@@ -14098,15 +14379,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,
@@ -14122,40 +14406,6 @@ async function listSchemas(aiexDir) {
 		return [];
 	}
 }
-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}`);
-	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)}%)`);
-			return { text: result.text };
-		}
-		return {
-			text: "",
-			filePath
-		};
-	}
-	if (ext === "pdf") {
-		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)`);
-		const mdPath = filePath.replace(PDF_EXT_RE, ".md");
-		try {
-			await fs.writeFile(mdPath, result.text);
-			consola.info(`Markdown saved: ${mdPath}`);
-		} catch {
-			const fallbackMd = path.join(os.tmpdir(), `${path.basename(filePath, ".pdf")}.md`);
-			await fs.writeFile(fallbackMd, result.text);
-			consola.info(`Markdown saved: ${fallbackMd}`);
-		}
-		return { text: result.text };
-	}
-	return { text: await fs.readFile(filePath, "utf-8") };
-}
 async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, filePath, modelOverride, options) {
 	const schemaLoad = await loadSchema(config, schemaName);
 	if (!schemaLoad.schema) {
@@ -14166,7 +14416,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 +14425,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 +14467,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 +14476,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 +14487,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 +14521,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 +14577,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 +14587,8 @@ 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) }));
+				await triggerWebhook(aiConfig, audit.id, schemaName, "extraction.failed", source, r.data, error instanceof Error ? error.message : String(error), r.tokensUsed, quiet);
 				return {
 					success: false,
 					error: error instanceof Error ? error.message : String(error),
@@ -14338,6 +14604,7 @@ async function runAuditedExtraction(options) {
 				notionPages,
 				tokensUsed: r.tokensUsed
 			});
+			await triggerWebhook(aiConfig, audit.id, schemaName, "extraction.success", source, r.data, void 0, r.tokensUsed, quiet);
 			return {
 				success: true,
 				outputPath: updated.outputPath,
@@ -14353,7 +14620,8 @@ 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 }));
+			await triggerWebhook(aiConfig, audit.id, schemaName, "extraction.failed", source, void 0, r.error || "Extraction failed", void 0, quiet);
 			return {
 				success: false,
 				error: r.error,
@@ -14368,8 +14636,12 @@ 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)
+			}));
 		}
+		await triggerWebhook(aiConfig, audit.id, schemaName, "extraction.failed", source, void 0, e instanceof Error ? e.message : String(e), void 0, quiet);
 		return {
 			success: false,
 			error: e instanceof Error ? e.message : String(e),
@@ -14378,99 +14650,41 @@ async function runAuditedExtraction(options) {
 		};
 	}
 }
-async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, modelOverride, options) {
-	const result = await runAuditedExtraction({
-		aiexDir,
-		config,
-		aiConfig,
-		schemaName,
-		source: {
-			type: "file",
-			filePath
-		},
-		modelOverride,
-		insert: options?.insert,
-		force: options?.force,
-		quiet: false
-	});
-	if (result.success) {
-		if (!result.skipped) consola.success(`Processed: ${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...`);
-	let files;
-	try {
-		files = listSupportedFiles(dir, globPattern);
-	} catch {
-		return {
-			ok: false,
-			successCount: 0,
-			failCount: 0,
-			error: `Cannot read directory: ${dir}`
-		};
-	}
-	if (files.length === 0) return {
-		ok: false,
-		successCount: 0,
-		failCount: 0,
-		error: `No supported files found in ${dir}`
-	};
-	consola.info(`Found ${files.length} file(s) to process`);
-	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))}`);
-		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`);
-	return {
-		ok: true,
-		successCount,
-		failCount
-	};
-}
 
 //#endregion
 //#region src/commands/dump.ts
 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 +14695,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 +14735,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 +14756,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,64 +14768,46 @@ 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...");
-		const formattedRows = rows.map((row) => {
-			const newRow = {};
-			columns.forEach((col) => {
-				const colName = col.name;
-				const val = row[colName];
-				const type = (schema?.properties?.[colName])?.type || "";
-				if (val === null || val === void 0) newRow[colName] = "";
-				else if (type === "boolean") if (format === "xlsx") newRow[colName] = val === 1 || val === "1" || val === true;
-				else newRow[colName] = val === 1 || val === "1" || val === true ? "true" : "false";
-				else if (type === "number" || type === "integer") if (val === "") newRow[colName] = "";
-				else {
-					const num = Number(val);
-					newRow[colName] = Number.isNaN(num) ? val : num;
-				}
-				else if (typeof val === "object") newRow[colName] = JSON.stringify(val);
-				else {
-					const dbType = (col.type || "").toLowerCase();
-					if ((dbType.includes("int") || dbType.includes("real") || dbType.includes("num") || dbType.includes("double") || dbType.includes("float")) && typeof val === "string" && val !== "") {
-						const num = Number(val);
-						newRow[colName] = Number.isNaN(num) ? val : num;
-					} else newRow[colName] = val;
-				}
-			});
-			return newRow;
-		});
-		s2.stop("Data formatted");
+		s2.start(t("command.dump.formatting"));
+		let formattedRows;
+		try {
+			formattedRows = formatRowsConformingToSchema(rows, columns, schema, format);
+			s2.stop(t("command.dump.formatted"));
+		} catch (error) {
+			s2.stop(t("command.dump.dbQueryFailed"));
+			failCommand(error instanceof Error ? error.message : String(error));
+			return;
+		}
 		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 buffer = generateExportBuffer(tableName, formattedRows, columns, format);
 			const outputDir = path.dirname(resolvedOutput);
 			if (!fs$1.existsSync(outputDir)) fs$1.mkdirSync(outputDir, { recursive: true });
-			if (format === "xlsx") {
-				const wb = XLSX.utils.book_new();
-				XLSX.utils.book_append_sheet(wb, ws, tableName.slice(0, 31));
-				XLSX.writeFile(wb, resolvedOutput);
-			} else {
-				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)}`);
+			fs$1.writeFileSync(resolvedOutput, buffer);
+			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 +14833,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 +14850,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 +14861,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 +14879,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 +14903,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 +14951,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 +14964,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 +14999,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 +15047,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 +15064,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 +15094,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 +15157,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 +15174,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 +15219,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 +15259,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 +15298,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 +15425,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 +15444,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 +15462,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 +15482,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 +15513,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 +15584,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 +15657,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 +15682,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);
 				}
 			}
@@ -15491,26 +15718,17 @@ function aiRoutes(config) {
 }
 
 //#endregion
-//#region src/server/routes/data.ts
+//#region src/core/data-service.ts
 const FILE_REGEX = /\.json$/;
 const EXTRACTION_TIMESTAMP_RE = /-\d{4}-\d{2}-\d{2}T/;
 const INTERNAL_ROWID_COLUMN = "__aiex_rowid";
 const TIMESTAMP_CLEANUP = /(\d{2})-(\d{2})-(\d{2})/;
 const TIMESTAMP_TZ = /(\d{3})Z/;
-const tableParamSchema = z.object({ name: z.string().regex(/^[a-z][a-z0-9_]*$/) });
-const extractionFileParamSchema = z.object({ name: z.string().regex(/^[\w.-]+\.json$/).refine((name$1) => name$1 === path.basename(name$1) && !name$1.includes("..")) });
-const tableQuerySchema = z.object({
-	page: z.coerce.number().int().min(1).catch(1),
-	pageSize: z.coerce.number().int().min(1).max(500).catch(50),
-	search: z.string().catch(""),
-	sortField: z.string().optional(),
-	sortOrder: z.preprocess((value) => typeof value === "string" ? value.toLowerCase() : value, z.enum(["asc", "desc"]).catch("asc")),
-	all: z.preprocess((value) => value === "true" || value === true, z.boolean().catch(false))
-});
-function invalidParamResponse$1(message) {
-	return (result, c) => {
-		if (!result.success) return c.json({ error: message }, 400);
-	};
+function schemaNameFromExtractionFile(name$1) {
+	const stem = name$1.replace(FILE_REGEX, "");
+	const match = stem.match(EXTRACTION_TIMESTAMP_RE);
+	if (!match || typeof match.index !== "number" || match.index <= 0) return null;
+	return stem.slice(0, match.index);
 }
 function getAuditNotionStatus(record) {
 	if (record.notionPages?.length) return "synced";
@@ -15537,50 +15755,233 @@ async function getRowExtractionActions(aiexDir, tableName) {
 	}
 	return actions;
 }
-function schemaNameFromExtractionFile(name$1) {
-	const stem = name$1.replace(FILE_REGEX, "");
-	const match = stem.match(EXTRACTION_TIMESTAMP_RE);
-	if (!match || typeof match.index !== "number" || match.index <= 0) return null;
-	return stem.slice(0, match.index);
-}
 function createReadonlyQueryDb(databasePath) {
 	return new Kysely({ dialect: new SqliteDialect({ database: new Database(databasePath, { readonly: true }) }) });
 }
+async function listExtractions(config) {
+	const aiexDir = path.dirname(config.schemaPath);
+	const extractedDir = path.join(aiexDir, "extracted");
+	await fs.mkdir(extractedDir, { recursive: true });
+	const jsonFiles = (await fs.readdir(extractedDir)).filter((f) => f.endsWith(".json") && !f.endsWith(".prompt.md"));
+	const auditRecords = await listExtractionAuditRecords(aiexDir);
+	const auditByOutputName = new Map(auditRecords.map((record) => [record.outputName, record]));
+	const records = [];
+	for (const file of jsonFiles) {
+		const schemaName = schemaNameFromExtractionFile(file);
+		if (!schemaName) continue;
+		const timestamp = file.replace(FILE_REGEX, "").slice(schemaName.length + 1).replace(/-/g, (d, i) => i === 4 || i === 7 ? "-" : d).replace(TIMESTAMP_CLEANUP, (_, h, m, s) => `${h}:${m}:${s}`).replace(TIMESTAMP_TZ, ".$1Z");
+		const filePath = path.join(extractedDir, file);
+		try {
+			const stat = await fs.stat(filePath);
+			const audit = auditByOutputName.get(file);
+			const notionPages = audit?.notionPages?.length ? audit.notionPages : void 0;
+			records.push({
+				name: file,
+				schemaName,
+				timestamp,
+				fileSize: stat.size,
+				modifiedAt: stat.mtime.toISOString(),
+				notionStatus: notionPages ? "synced" : audit?.status === "failed" ? "failed" : "not_synced",
+				notionPages,
+				notionError: !notionPages && audit?.status === "failed" ? audit.error : void 0
+			});
+		} catch {
+			continue;
+		}
+	}
+	records.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+	return records;
+}
+async function listTables(config) {
+	const schemaDir = config.schemaPath;
+	let schemaFiles = [];
+	try {
+		schemaFiles = (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json"));
+	} catch {
+		schemaFiles = [];
+	}
+	let db = null;
+	let dbTables = [];
+	try {
+		db = createReadonlyQueryDb(config.databasePath);
+		dbTables = (await sql`
+      select name
+      from sqlite_master
+      where type = 'table' and name not like 'sqlite_%' and name not like '_%'
+      order by name
+    `.execute(db)).rows.map((row) => row.name);
+	} catch {} finally {
+		await db?.destroy();
+	}
+	const tables = [];
+	for (const file of schemaFiles) try {
+		const schema = await readFile(path.join(schemaDir, file));
+		const tableName = schema.table?.name;
+		if (!tableName) continue;
+		tables.push({
+			name: tableName,
+			title: schema.title || tableName,
+			hasData: dbTables.includes(tableName)
+		});
+	} catch {
+		continue;
+	}
+	return tables;
+}
+async function getTableData(config, tableName, query) {
+	const { page, pageSize, search, sortField, sortOrder, all } = query;
+	const aiexDir = path.dirname(config.schemaPath);
+	let db;
+	try {
+		db = createReadonlyQueryDb(config.databasePath);
+	} catch {
+		throw new Error(t("server.dbNotFound"));
+	}
+	try {
+		if ((await sql`
+      select name
+      from sqlite_master
+      where type = 'table' and name = ${tableName}
+    `.execute(db)).rows.length === 0) throw new Error(t("server.tableNotFound", { name: tableName }));
+		const columns = (await sql`
+      pragma table_info(${sql.table(tableName)})
+    `.execute(db)).rows.map((col) => ({
+			name: col.name,
+			type: col.type,
+			notNull: !!col.notnull,
+			pk: !!col.pk
+		}));
+		const searchConditions = columns.map((col) => sql`${sql.ref(col.name)} like ${`%${search}%`}`);
+		const searchCondition = search ? sql`where ${sql.join(searchConditions, sql` or `)}` : sql``;
+		const sortColumn = columns.find((col) => col.name === sortField);
+		const orderBy = sortColumn ? sql`order by ${sql.ref(sortColumn.name)} ${sql.raw(sortOrder === "desc" ? "desc" : "asc")}` : sql``;
+		const total = (await sql`
+      select count(*) as count
+      from ${sql.table(tableName)}
+      ${searchCondition}
+    `.execute(db)).rows[0]?.count ?? 0;
+		const offset = (page - 1) * pageSize;
+		const totalPages = all ? 1 : Math.max(1, Math.ceil(total / pageSize));
+		const result = all ? await sql`
+          select rowid as ${sql.raw(INTERNAL_ROWID_COLUMN)}, *
+          from ${sql.table(tableName)}
+          ${searchCondition}
+          ${orderBy}
+        `.execute(db) : await sql`
+          select rowid as ${sql.raw(INTERNAL_ROWID_COLUMN)}, *
+          from ${sql.table(tableName)}
+          ${searchCondition}
+          ${orderBy}
+          limit ${pageSize}
+          offset ${offset}
+        `.execute(db);
+		const actionsByRowId = await getRowExtractionActions(aiexDir, tableName);
+		const rowActions = Object.fromEntries(result.rows.map((row, index) => {
+			const rowId = row[INTERNAL_ROWID_COLUMN];
+			const action = rowId === null || rowId === void 0 ? void 0 : actionsByRowId.get(String(rowId));
+			return action ? [String(index), action] : null;
+		}).filter((entry) => !!entry));
+		const rows = result.rows.map(({ [INTERNAL_ROWID_COLUMN]: _rowid, ...row }) => row);
+		const schemaDir = config.schemaPath;
+		let schema = null;
+		try {
+			const schemaFiles = (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json"));
+			for (const file of schemaFiles) {
+				const s = await readFile(path.join(schemaDir, file));
+				if (s.table?.name === tableName) {
+					schema = s;
+					break;
+				}
+			}
+		} catch {}
+		return {
+			columns,
+			rows,
+			rowActions,
+			total,
+			page: all ? 1 : page,
+			pageSize: all ? total : pageSize,
+			totalPages,
+			schema
+		};
+	} finally {
+		await db.destroy();
+	}
+}
+async function retryNotionSync(config, fileName) {
+	const aiexDir = path.dirname(config.schemaPath);
+	const extractedDir = path.join(aiexDir, "extracted");
+	const filePath = path.join(extractedDir, fileName);
+	const schemaName = schemaNameFromExtractionFile(fileName);
+	if (!schemaName) throw new Error(t("server.cannotInferSchema"));
+	const aiConfig = await readAIConfig(aiexDir);
+	if (!aiConfig?.notion?.enabled) throw new Error(t("errors.notion.notEnabled"));
+	if (!aiConfig.notion.schemas?.[schemaName]?.databaseId?.trim()) throw new Error(t("errors.notion.noSchemaConfig", { name: schemaName }));
+	try {
+		const data = await readFile(filePath);
+		if (!data || typeof data !== "object" || Array.isArray(data)) throw new Error(t("errors.ai.extractionNotObject"));
+		const page = await writeNotionPage(aiConfig.notion, schemaName, data);
+		const notionPages = [{
+			databaseId: page.databaseId,
+			pageId: page.pageId
+		}];
+		let record = (await listExtractionAuditRecords(aiexDir)).find((record$1) => record$1.outputName === fileName);
+		if (!record) record = await createExtractionAuditRecord(aiexDir, {
+			schemaName,
+			source: {
+				type: "file",
+				filePath,
+				fileName
+			}
+		});
+		if (record) await updateExtractionAuditRecord(aiexDir, record.id, {
+			status: "succeeded",
+			outputPath: filePath,
+			outputName: fileName,
+			notionPages,
+			error: void 0
+		});
+		return {
+			success: true,
+			notionPages
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		const record = (await listExtractionAuditRecords(aiexDir)).find((record$1) => record$1.outputName === fileName);
+		if (record) await updateExtractionAuditRecord(aiexDir, record.id, {
+			status: "failed",
+			outputPath: filePath,
+			outputName: fileName,
+			error: message
+		});
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/server/routes/data.ts
+const tableParamSchema = z.object({ name: z.string().regex(/^[a-z][a-z0-9_]*$/) });
+const extractionFileParamSchema = z.object({ name: z.string().regex(/^[\w.-]+\.json$/).refine((name$1) => name$1 === path.basename(name$1) && !name$1.includes("..")) });
+const tableQuerySchema = z.object({
+	page: z.coerce.number().int().min(1).catch(1),
+	pageSize: z.coerce.number().int().min(1).max(500).catch(50),
+	search: z.string().catch(""),
+	sortField: z.string().optional(),
+	sortOrder: z.preprocess((value) => typeof value === "string" ? value.toLowerCase() : value, z.enum(["asc", "desc"]).catch("asc")),
+	all: z.preprocess((value) => value === "true" || value === true, z.boolean().catch(false))
+});
+function invalidParamResponse$1(message) {
+	return (result, c) => {
+		if (!result.success) return c.json({ error: message }, 400);
+	};
+}
 function dataRoutes(config) {
 	const app = new Hono();
 	const aiexDir = path.dirname(config.schemaPath);
 	const extractedDir = path.join(aiexDir, "extracted");
 	app.get("/data", async (c) => {
 		try {
-			await fs.mkdir(extractedDir, { recursive: true });
-			const jsonFiles = (await fs.readdir(extractedDir)).filter((f) => f.endsWith(".json") && !f.endsWith(".prompt.md"));
-			const auditRecords = await listExtractionAuditRecords(aiexDir);
-			const auditByOutputName = new Map(auditRecords.map((record) => [record.outputName, record]));
-			const records = [];
-			for (const file of jsonFiles) {
-				const schemaName = schemaNameFromExtractionFile(file);
-				if (!schemaName) continue;
-				const timestamp = file.replace(FILE_REGEX, "").slice(schemaName.length + 1).replace(/-/g, (d, i) => i === 4 || i === 7 ? "-" : d).replace(TIMESTAMP_CLEANUP, (_, h, m, s) => `${h}:${m}:${s}`).replace(TIMESTAMP_TZ, ".$1Z");
-				const filePath = path.join(extractedDir, file);
-				try {
-					const stat = await fs.stat(filePath);
-					const audit = auditByOutputName.get(file);
-					const notionPages = audit?.notionPages?.length ? audit.notionPages : void 0;
-					records.push({
-						name: file,
-						schemaName,
-						timestamp,
-						fileSize: stat.size,
-						modifiedAt: stat.mtime.toISOString(),
-						notionStatus: notionPages ? "synced" : audit?.status === "failed" ? "failed" : "not_synced",
-						notionPages,
-						notionError: !notionPages && audit?.status === "failed" ? audit.error : void 0
-					});
-				} catch {
-					continue;
-				}
-			}
-			records.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+			const records = await listExtractions(config);
 			return c.json(records);
 		} catch (error) {
 			return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
@@ -15588,127 +15989,25 @@ function dataRoutes(config) {
 	});
 	app.get("/data/tables", async (c) => {
 		try {
-			const schemaDir = config.schemaPath;
-			let schemaFiles = [];
-			try {
-				schemaFiles = (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json"));
-			} catch {
-				schemaFiles = [];
-			}
-			let db = null;
-			let dbTables = [];
-			try {
-				db = createReadonlyQueryDb(config.databasePath);
-				dbTables = (await sql`
-          select name
-          from sqlite_master
-          where type = 'table' and name not like 'sqlite_%' and name not like '_%'
-          order by name
-        `.execute(db)).rows.map((row) => row.name);
-			} catch {} finally {
-				await db?.destroy();
-			}
-			const tables = [];
-			for (const file of schemaFiles) try {
-				const schema = await readFile(path.join(schemaDir, file));
-				const tableName = schema.table?.name;
-				if (!tableName) continue;
-				tables.push({
-					name: tableName,
-					title: schema.title || tableName,
-					hasData: dbTables.includes(tableName)
-				});
-			} catch {
-				continue;
-			}
+			const tables = await listTables(config);
 			return c.json(tables);
 		} catch (error) {
 			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);
-		}
+		const query = c.req.valid("query");
 		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);
-			const columns = (await sql`
-          pragma table_info(${sql.table(tableName)})
-        `.execute(db)).rows.map((col) => ({
-				name: col.name,
-				type: col.type,
-				notNull: !!col.notnull,
-				pk: !!col.pk
-			}));
-			const searchConditions = columns.map((col) => sql`${sql.ref(col.name)} like ${`%${search}%`}`);
-			const searchCondition = search ? sql`where ${sql.join(searchConditions, sql` or `)}` : sql``;
-			const sortColumn = columns.find((col) => col.name === sortField);
-			const orderBy = sortColumn ? sql`order by ${sql.ref(sortColumn.name)} ${sql.raw(sortOrder === "desc" ? "desc" : "asc")}` : sql``;
-			const total = (await sql`
-          select count(*) as count
-          from ${sql.table(tableName)}
-          ${searchCondition}
-        `.execute(db)).rows[0]?.count ?? 0;
-			const offset = (page - 1) * pageSize;
-			const totalPages = all ? 1 : Math.max(1, Math.ceil(total / pageSize));
-			const result = all ? await sql`
-              select rowid as ${sql.raw(INTERNAL_ROWID_COLUMN)}, *
-              from ${sql.table(tableName)}
-              ${searchCondition}
-              ${orderBy}
-            `.execute(db) : await sql`
-              select rowid as ${sql.raw(INTERNAL_ROWID_COLUMN)}, *
-              from ${sql.table(tableName)}
-              ${searchCondition}
-              ${orderBy}
-              limit ${pageSize}
-              offset ${offset}
-            `.execute(db);
-			const actionsByRowId = await getRowExtractionActions(aiexDir, tableName);
-			const rowActions = Object.fromEntries(result.rows.map((row, index) => {
-				const rowId = row[INTERNAL_ROWID_COLUMN];
-				const action = rowId === null || rowId === void 0 ? void 0 : actionsByRowId.get(String(rowId));
-				return action ? [String(index), action] : null;
-			}).filter((entry) => !!entry));
-			const rows = result.rows.map(({ [INTERNAL_ROWID_COLUMN]: _rowid, ...row }) => row);
-			const schemaDir = config.schemaPath;
-			let schema = null;
-			try {
-				const schemaFiles = (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json"));
-				for (const file of schemaFiles) {
-					const s = await readFile(path.join(schemaDir, file));
-					if (s.table?.name === tableName) {
-						schema = s;
-						break;
-					}
-				}
-			} catch {}
-			return c.json({
-				columns,
-				rows,
-				rowActions,
-				total,
-				page: all ? 1 : page,
-				pageSize: all ? total : pageSize,
-				totalPages,
-				schema
-			});
+			const result = await getTableData(config, tableName, query);
+			return c.json(result);
 		} catch (error) {
-			return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
-		} finally {
-			await db.destroy();
+			const errMessage = error instanceof Error ? error.message : String(error);
+			const status = errMessage.includes("not found") ? 404 : 500;
+			return c.json({ error: errMessage }, status);
 		}
 	});
-	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,66 +16018,20 @@ 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"
-		}, 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."
-		}, 400);
-		if (!aiConfig.notion.schemas?.[schemaName]?.databaseId?.trim()) return c.json({
+		if (!schemaNameFromExtractionFile(name$1)) return c.json({
 			success: false,
-			error: `Notion database is not configured for schema "${schemaName}".`
+			error: t("server.cannotInferSchema")
 		}, 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."
-			}, 400);
-			const page = await writeNotionPage(aiConfig.notion, schemaName, data);
-			const notionPages = [{
-				databaseId: page.databaseId,
-				pageId: page.pageId
-			}];
-			let record = (await listExtractionAuditRecords(aiexDir)).find((record$1) => record$1.outputName === name$1);
-			if (!record) record = await createExtractionAuditRecord(aiexDir, {
-				schemaName,
-				source: {
-					type: "file",
-					filePath,
-					fileName: name$1
-				}
-			});
-			if (record) await updateExtractionAuditRecord(aiexDir, record.id, {
-				status: "succeeded",
-				outputPath: filePath,
-				outputName: name$1,
-				notionPages,
-				error: void 0
-			});
-			return c.json({
-				success: true,
-				notionPages
-			});
+			const result = await retryNotionSync(config, name$1);
+			return c.json(result);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			const record = (await listExtractionAuditRecords(aiexDir)).find((record$1) => record$1.outputName === name$1);
-			if (record) await updateExtractionAuditRecord(aiexDir, record.id, {
-				status: "failed",
-				outputPath: filePath,
-				outputName: name$1,
-				error: message
-			});
 			return c.json({
 				success: false,
 				error: message
@@ -15837,15 +16090,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 +16124,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 +16177,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 +16234,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 +16263,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 +16288,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 +16304,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 +16324,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 +16335,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 +16376,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 +16426,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 +16471,7 @@ const subCommands = {
 
 //#endregion
 //#region src/cli.ts
+await initI18n();
 seedConfig(createConfig());
 updateNotifier({ pkg: package_default }).notify();
 process.on("uncaughtException", (error) => {
@@ -16229,7 +16484,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);