@syntholoc/mcp 0.4.0 → 0.6.1

package/dist/build-server-3r0JYcI7.js

@@ -0,0 +1,2098 @@
+import { ADD_LOCALE, APPROVE_TRANSLATION, APP_INFO, BUILD_OTA_RELEASE, CANCEL_OTA_RELEASE, CONFIGURE_LLM_PROVIDER, CONFIG_RESOURCE, CONNECT_REPOSITORY, COST_ANALYTICS, CREATE_GLOSSARY_TERM, CREATE_OTA_CHANNEL, CREATE_OTA_DELIVERY_KEY, CREATE_OTA_DISTRIBUTION, CREATE_PROJECT, CREATE_STYLE_GUIDE, DELETE_GLOSSARY_TERM, DELETE_KEY, DELETE_OTA_CHANNEL, DELETE_OTA_RELEASE, DISABLE_OTA_DISTRIBUTION, DISCONNECT_REPOSITORY, ENABLE_OTA_DISTRIBUTION, EXPORT_DOCUMENT_LOCALE, EXPORT_LOCALE, GENERATE_STYLE_GUIDE, GET_JOB, GET_PROJECT, GITHUB_APP, GITHUB_INSTALLATIONS, GITHUB_INSTALLATION_REPOS, IMPORT_SOURCE_STRINGS, IMPORT_TRANSLATIONS, LIST_GLOSSARY, LIST_JOBS, LIST_KEYS, LIST_LLM_PROVIDERS, LIST_LOCALES, LIST_PROJECTS, LIST_QA_ISSUES, LIST_REPOSITORIES, LIST_STYLE_GUIDES, LIST_TRANSLATIONS, LOCALE_PROGRESS, MY_ORGANIZATIONS, OTA_CHANNELS, OTA_CHANNEL_HISTORY, OTA_DELIVERY_KEYS, OTA_DISTRIBUTION, OTA_DISTRIBUTIONS, OTA_PREVIEW_ASSET, OTA_RELEASE, OTA_RELEASES, OTA_RELEASE_DIFF, OTA_USAGE, PIN_OTA_RELEASE, PROJECTS_RESOURCE, PROJECT_ANALYTICS, PROJECT_RESOURCE, PROMOTE_OTA_RELEASE, PULL_TRANSLATIONS, PUSH_TRANSLATIONS, REJECT_TRANSLATION, REMOVE_LOCALE, RETIRE_OTA_DISTRIBUTION, REVOKE_OTA_DELIVERY_KEY, ROLLBACK_OTA_CHANNEL, RUN_LOCALE_QA, RUN_QA, SEED_STARTER_LOCALES, SET_TRANSLATION, SUGGEST_GLOSSARY_TERMS, SYNC_REPOSITORY, TM_ENTRIES, TM_SEARCH, TM_STATS, TRANSLATE_KEY, TRANSLATE_LOCALE, UPDATE_GLOSSARY_TERM, UPDATE_KEY, UPDATE_OTA_DISTRIBUTION, UPDATE_PROJECT, UPDATE_REPOSITORY, UPSERT_KEYS, USAGE, waitForJob } from "@syntholoc/sdk";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+//#region src/filter.ts
+/** Converts a `*`-wildcard pattern to a full-match RegExp (other chars are literal). */
+function wildcardToRegExp(pattern) {
+	const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	return new RegExp(`^${escaped}$`);
+}
+function matchesAnyPattern(name, patterns) {
+	return patterns.some((re) => re.test(name));
+}
+/**
+* Overrides the server's `registerTool` so tools that fail the read-only or
+* name-pattern filters are silently dropped. Tool-set (group) selection happens
+* separately in `registerAllTools` by skipping whole groups. Returns the same
+* server (unmodified when no per-tool filtering is requested).
+*
+* Callers of `registerTool` ignore its return value, so skipped tools resolve to
+* `undefined` — no dummy handle is needed.
+*/
+function applyToolFilter(server, opts) {
+	const patterns = (opts.toolFilter ?? []).filter(Boolean).map(wildcardToRegExp);
+	if (!opts.readOnly && patterns.length === 0) return server;
+	const original = server.registerTool.bind(server);
+	const filtered = (name, config, handler) => {
+		const readOnly = config.annotations?.readOnlyHint;
+		if (opts.readOnly && !readOnly) return void 0;
+		if (patterns.length > 0 && !matchesAnyPattern(name, patterns)) return;
+		return original(name, config, handler);
+	};
+	server.registerTool = filtered;
+	return server;
+}
+/** Parses a comma-separated header/env value into a trimmed, non-empty string list. */
+function parseList(value) {
+	if (!value) return void 0;
+	const items = value.split(",").map((s) => s.trim()).filter(Boolean);
+	return items.length > 0 ? items : void 0;
+}
+//#endregion
+//#region src/prompts.ts
+function userMessage(text) {
+	return { messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text
+		}
+	}] };
+}
+/** Registers workflow prompts for MCP clients that expose server-provided prompts. */
+function registerPrompts(server) {
+	server.registerPrompt("localize_changed", {
+		title: "Localize changed keys",
+		description: "Sync changed source strings from the local diff, translate them, and write back.",
+		argsSchema: { projectId: z.string().optional() }
+	}, ({ projectId }) => userMessage([
+		"Localize my recent source-string changes via Syntholoc:",
+		"1. Read `.syntholoc/config.json` for the source file(s) and project.",
+		projectId ? `   (Use project ${projectId} if config is missing.)` : "",
+		"2. From `git diff` on the source file(s), collect added/changed keys and `upsert_keys` (dryRun first to preview).",
+		"   - MULTI-FILE / namespaced project (a file per namespace, e.g. messages/en/home.json): import each",
+		"     changed file with `import_source_strings` passing `keyPrefix` = the namespace (the filename",
+		"     without extension, e.g. \"home\"). This keeps overlapping keys from different files distinct.",
+		"3. Call `get_config` for `maxBulkSize`. For EACH target locale check `locale_progress` → `untranslated`.",
+		"   - If untranslated >= maxBulkSize: `translate_locale` (scope UNTRANSLATED) and `wait_for_job`.",
+		"   - If below the threshold: tell me the counts and ASK whether to translate now or accumulate.",
+		"4. `export_locale` for each translated locale and write the result back into the mapped local files.",
+		"   - Namespaced project: call `export_locale` once per namespace with the same `keyPrefix` (the prefix",
+		"     is stripped on export) and write each result to its file, e.g. messages/{locale}/home.json.",
+		"5. Summarize keys added, locales translated, and the cost from the job usage."
+	].filter(Boolean).join("\n")));
+	server.registerPrompt("review_locale", {
+		title: "Review a locale",
+		description: "Surface low-confidence and QA-flagged translations for a locale and help fix them.",
+		argsSchema: {
+			projectId: z.string(),
+			locale: z.string()
+		}
+	}, ({ projectId, locale }) => userMessage([
+		`Review the "${locale}" locale in project ${projectId}:`,
+		"1. Resolve the locale id via `list_locales`.",
+		"2. `list_qa_issues` and `list_translations` (focus on low qaScore / non-approved).",
+		"3. For each problem, propose a fix; apply with `set_translation`, then `approve_translation`.",
+		"4. Summarize what changed and what still needs human attention."
+	].join("\n")));
+	server.registerPrompt("bootstrap_project", {
+		title: "Bootstrap a project from this repo",
+		description: "Detect i18n files, create a Syntholoc project, seed locales, and write .syntholoc/config.json.",
+		argsSchema: {}
+	}, () => userMessage([
+		"Set up Syntholoc for this repository. PREFER the Git-sync path — it pulls every",
+		"source string (and any existing translations) in one server-side sync and keeps",
+		"the repo in sync going forward. Only fall back to manual imports if the user",
+		"declines Git or the code lives outside a supported host.",
+		"",
+		"1. Find the i18n source files and infer the source locale. Note the LAYOUT:",
+		"   - Single file per locale (e.g. messages/en.json) → one mapping, no namespace.",
+		"   - A directory per locale with many namespace files (e.g. messages/en/home.json, common.json) →",
+		"     each file is a NAMESPACE. Syntholoc stores a flat key space, so each file is imported under a",
+		"     `keyPrefix` = its namespace to avoid collisions between files.",
+		"2. `create_project`, then `seed_starter_locales` (or `add_locale`) for the target languages. Use valid",
+		"   BCP-47 codes (e.g. \"zh-CN\", not \"cn\"); `add_locale` accepts `code` or `locale`. Region-ambiguous",
+		"   languages MUST be qualified — \"pt\" → \"pt-BR\" or \"pt-PT\", \"zh\" → \"zh-CN\" or \"zh-TW\". The tools reject",
+		"   ambiguous codes and return the candidates; if a source filename is just \"pt\", ask which region (or",
+		"   default to the likeliest) and record the file→locale mapping in the config `translation` pattern.",
+		"   (Target locales must exist before a Git pull so their translation files import.)",
+		"3. RECOMMENDED — connect the repo and sync, instead of pushing strings one by one:",
+		"   a. `list_repositories`. If one is already connected, skip to (e).",
+		"   b. Write `.syntholoc/config.json` FIRST and commit it to the source branch — the server reads it",
+		"      from the repo as the SOURCE OF TRUTH for mappings on every sync/pull/write-back (Crowdin-style),",
+		"      so it must land in the branch before the first sync. Schema (https://syntholoc.com/schemas/config.json):",
+		"      the `projectId`, `sourceLocale`, and a Crowdin-style `files` array of `{ source, translation }`",
+		"      patterns, e.g. { \"source\": \"messages/en/*.json\", \"translation\": \"messages/{locale}/%original_file_name%\" }.",
+		"      - Placeholders: `{locale}` (or %locale% / %two_letters_code% / %original_file_name% / %original_path%).",
+		"      - If a locale's ON-DISK code differs from its BCP-47 code (e.g. \"zh-CN\" stored as \"cn\", \"pt-BR\" as \"pt\"),",
+		"        add `languagesMapping`, e.g. { \"two_letters_code\": { \"zh-CN\": \"cn\", \"pt-BR\": \"pt\" } }.",
+		"      - Do NOT invent fields like `i18nDir`, `format: \"nested-dirs\"`, or `localeMapping` — they are not read.",
+		"      - CRITICAL: `.syntholoc/config.json` MUST be committed and tracked — it is the mapping source of",
+		"        truth the server reads from the branch. NEVER add `.syntholoc` (or the config file) to `.gitignore`.",
+		"        If `.gitignore` already ignores it (a common reflex, next to `.claude`), remove that line. After",
+		"        committing, VERIFY it is tracked (e.g. `git ls-files .syntholoc/config.json` returns the path, or",
+		"        `git check-ignore` reports nothing) — an ignored config means every sync/pull/write-back resolves",
+		"        zero files and silently opens no PR.",
+		"   c. Connect it with `connect_repository`. Ask the user which method they prefer:",
+		"      - GitHub App (no token, recommended): `get_github_app_install_url` → give the URL to the user",
+		"        to open and authorize (you cannot click it for them; you may offer to open it via the shell).",
+		"        Once they confirm, `list_github_installations` → `list_github_installation_repos` to pick the",
+		"        repo, then `connect_repository` with that `installationId`.",
+		"      - Token (any host): ask the user to paste a personal access token (repo read + PR scope), then",
+		"        `connect_repository` with `token`. Treat the token as a secret — do not echo it back.",
+		"   d. `files`/`paths` on `connect_repository` are an OPTIONAL fallback used only when the repo has no",
+		"      committed `.syntholoc/config.json`. If you committed the config in (b) you may pass the same `files`",
+		"      for redundancy, but the in-repo config wins. Same Crowdin placeholders as the config file.",
+		"   e. `sync_repository` — imports ALL source strings from the repo at once and opens the translation PR.",
+		"      Then `pull_translations` to import any translation files already in the repo (choose `conflict`",
+		"      KEEP_APPROVED to preserve in-app edits).",
+		"   f. `wait_for_job` on the returned job id, then report keys imported and the PR url.",
+		"4. FALLBACK — file-based import when the user does NOT want Git integration:",
+		"   - Single file → `import_source_strings` once.",
+		"   - Namespaced → `import_source_strings` once PER FILE with `keyPrefix` set to the namespace",
+		"     (filename without extension). Keys become e.g. `home.title`, `common.title`.",
+		"5. Offer to run the localize_changed flow next."
+	].join("\n")));
+}
+//#endregion
+//#region src/resources.ts
+function json(uri, data) {
+	return { contents: [{
+		uri: uri.href,
+		mimeType: "application/json",
+		text: JSON.stringify(data, null, 2)
+	}] };
+}
+/** Registers read-only MCP resources so the model can pull context cheaply. */
+function registerResources(server, gql) {
+	server.registerResource("config", "syntholoc://config", {
+		title: "Syntholoc config",
+		description: "Server metadata incl. maxBulkSize (auto-translate batch threshold).",
+		mimeType: "application/json"
+	}, async (uri) => json(uri, (await gql.request(CONFIG_RESOURCE)).appInfo));
+	server.registerResource("organizations", "syntholoc://organizations", {
+		title: "Organizations",
+		description: "Organizations you belong to (id, name, slug, your role). Pin one for a request with the `syntholoc-org-id` header; otherwise the earliest org is used.",
+		mimeType: "application/json"
+	}, async (uri) => json(uri, (await gql.request(MY_ORGANIZATIONS)).myProjects.map((g) => ({
+		...g.organization,
+		viewerRole: g.viewerRole
+	}))));
+	server.registerResource("projects", "syntholoc://projects", {
+		title: "Projects",
+		description: "All localization projects in the active organization.",
+		mimeType: "application/json"
+	}, async (uri) => json(uri, (await gql.request(PROJECTS_RESOURCE)).projects));
+	server.registerResource("project", new ResourceTemplate("syntholoc://project/{projectId}", { list: void 0 }), {
+		title: "Project overview",
+		description: "A project with its locales and per-locale progress.",
+		mimeType: "application/json"
+	}, async (uri, { projectId }) => json(uri, await gql.request(PROJECT_RESOURCE, { id: String(projectId) })));
+	server.registerResource("project-keys", new ResourceTemplate("syntholoc://project/{projectId}/keys", { list: void 0 }), {
+		title: "Project source keys",
+		description: "Source keys in a project (first 100).",
+		mimeType: "application/json"
+	}, async (uri, { projectId }) => json(uri, (await gql.request(LIST_KEYS, {
+		projectId: String(projectId),
+		skip: 0,
+		take: 100
+	})).keys));
+	server.registerResource("project-locales", new ResourceTemplate("syntholoc://project/{projectId}/locales", { list: void 0 }), {
+		title: "Project locales",
+		description: "Target locales configured for a project.",
+		mimeType: "application/json"
+	}, async (uri, { projectId }) => json(uri, (await gql.request(LIST_LOCALES, { projectId: String(projectId) })).locales));
+	server.registerResource("project-progress", new ResourceTemplate("syntholoc://project/{projectId}/progress", { list: void 0 }), {
+		title: "Project progress",
+		description: "Per-locale translation progress and open QA issues for a project.",
+		mimeType: "application/json"
+	}, async (uri, { projectId }) => json(uri, (await gql.request(PROJECT_ANALYTICS, { projectId: String(projectId) })).projectAnalytics));
+	server.registerResource("project-jobs", new ResourceTemplate("syntholoc://project/{projectId}/jobs", { list: void 0 }), {
+		title: "Project jobs",
+		description: "Recent background jobs (translate / QA / git sync) for a project.",
+		mimeType: "application/json"
+	}, async (uri, { projectId }) => json(uri, (await gql.request(LIST_JOBS, {
+		projectId: String(projectId),
+		skip: 0,
+		take: 25
+	})).jobs));
+	server.registerResource("project-qa-issues", new ResourceTemplate("syntholoc://project/{projectId}/locale/{localeId}/qa-issues", { list: void 0 }), {
+		title: "Locale QA issues",
+		description: "Open QA issues for a locale, with issue-type facets.",
+		mimeType: "application/json"
+	}, async (uri, { projectId, localeId }) => json(uri, await gql.request(LIST_QA_ISSUES, {
+		projectId: String(projectId),
+		localeId: String(localeId),
+		skip: 0,
+		take: 25
+	})));
+	server.registerResource("glossary", "syntholoc://glossary", {
+		title: "Glossary",
+		description: "Organization-wide glossary terms (first 100).",
+		mimeType: "application/json"
+	}, async (uri) => json(uri, (await gql.request(LIST_GLOSSARY, {
+		skip: 0,
+		take: 100
+	})).glossaryTerms));
+	server.registerResource("style-guides", "syntholoc://style-guides", {
+		title: "Style guides",
+		description: "Organization-wide style guides.",
+		mimeType: "application/json"
+	}, async (uri) => json(uri, (await gql.request(LIST_STYLE_GUIDES, {})).styleGuides));
+	server.registerResource("tm", "syntholoc://tm", {
+		title: "Translation memory",
+		description: "Organization-wide Translation Memory coverage: entry counts per target locale.",
+		mimeType: "application/json"
+	}, async (uri) => json(uri, (await gql.request(TM_STATS, {})).tmStats));
+}
+//#endregion
+//#region src/util.ts
+/** Wraps a value as an MCP text result (pretty-printed JSON). */
+function jsonResult(data) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(data, null, 2)
+	}] };
+}
+/**
+* Wraps a validation failure as an MCP tool error. Returned rather than thrown so
+* the model sees an actionable message instead of a transport-level failure.
+*/
+function errorResult(message) {
+	return {
+		content: [{
+			type: "text",
+			text: message
+		}],
+		isError: true
+	};
+}
+//#endregion
+//#region src/tools/ota.ts
+function registerOtaTools(server, gql) {
+	server.registerTool("list_ota_distributions", {
+		title: "otaDistributions",
+		description: "otaDistributions for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			skip: z.number().int().min(0).optional(),
+			take: z.number().int().min(0).optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(OTA_DISTRIBUTIONS, vars)).otaDistributions));
+	server.registerTool("get_ota_distribution", {
+		title: "otaDistribution",
+		description: "otaDistribution for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(OTA_DISTRIBUTION, vars)).otaDistribution));
+	server.registerTool("list_ota_releases", {
+		title: "otaReleases",
+		description: "otaReleases for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			skip: z.number().int().min(0).optional(),
+			take: z.number().int().min(0).optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(OTA_RELEASES, vars)).otaReleases));
+	server.registerTool("get_ota_release", {
+		title: "otaRelease",
+		description: "otaRelease for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			releaseId: z.string()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(OTA_RELEASE, vars)).otaRelease));
+	server.registerTool("list_ota_channels", {
+		title: "otaChannels",
+		description: "otaChannels for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(OTA_CHANNELS, vars)).otaChannels));
+	server.registerTool("get_ota_channel_history", {
+		title: "otaChannelHistory",
+		description: "otaChannelHistory for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			channelId: z.string(),
+			skip: z.number().int().min(0).optional(),
+			take: z.number().int().min(0).optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(OTA_CHANNEL_HISTORY, vars)).otaChannelHistory));
+	server.registerTool("get_ota_release_diff", {
+		title: "otaReleaseDiff",
+		description: "otaReleaseDiff for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			from: z.string(),
+			to: z.string()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(OTA_RELEASE_DIFF, vars)).otaReleaseDiff));
+	server.registerTool("list_ota_delivery_keys", {
+		title: "otaDeliveryKeys",
+		description: "otaDeliveryKeys for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			skip: z.number().int().min(0).optional(),
+			take: z.number().int().min(0).optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(OTA_DELIVERY_KEYS, vars)).otaDeliveryKeys));
+	server.registerTool("get_ota_usage", {
+		title: "otaUsage",
+		description: "otaUsage for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(OTA_USAGE, vars)).otaUsage));
+	server.registerTool("create_ota_distribution", {
+		title: "createOtaDistribution",
+		description: "createOtaDistribution for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			input: z.object({
+				name: z.string(),
+				platform: z.enum([
+					"WEB",
+					"ANDROID",
+					"IOS"
+				]),
+				catalogVersion: z.string(),
+				accessMode: z.enum(["PUBLIC", "PROTECTED"]),
+				config: z.record(z.string(), z.unknown())
+			})
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(CREATE_OTA_DISTRIBUTION, vars)).createOtaDistribution));
+	server.registerTool("update_ota_distribution", {
+		title: "updateOtaDistribution",
+		description: "updateOtaDistribution for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			name: z.string(),
+			config: z.record(z.string(), z.unknown()),
+			expectedConfigVersion: z.number().int().min(0)
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(UPDATE_OTA_DISTRIBUTION, vars)).updateOtaDistribution));
+	server.registerTool("disable_ota_distribution", {
+		title: "disableOtaDistribution",
+		description: "disableOtaDistribution for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(DISABLE_OTA_DISTRIBUTION, vars)).disableOtaDistribution));
+	server.registerTool("enable_ota_distribution", {
+		title: "enableOtaDistribution",
+		description: "enableOtaDistribution for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(ENABLE_OTA_DISTRIBUTION, vars)).enableOtaDistribution));
+	server.registerTool("retire_ota_distribution", {
+		title: "retireOtaDistribution",
+		description: "retireOtaDistribution for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(RETIRE_OTA_DISTRIBUTION, vars)).retireOtaDistribution));
+	server.registerTool("build_ota_release", {
+		title: "buildOtaRelease",
+		description: "Build a frozen translation release without publishing it. Idempotency key is required. Poll the returned jobId with wait_for_job.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			idempotencyKey: z.string()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(BUILD_OTA_RELEASE, vars)).buildOtaRelease));
+	server.registerTool("cancel_ota_release", {
+		title: "cancelOtaRelease",
+		description: "cancelOtaRelease for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			releaseId: z.string()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(CANCEL_OTA_RELEASE, vars)).cancelOtaRelease));
+	server.registerTool("promote_ota_release", {
+		title: "promoteOtaRelease",
+		description: "Publish the specified READY release to a channel, including production. Requires the currently observed generation.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			releaseId: z.string(),
+			channel: z.string(),
+			expectedGeneration: z.number().int().min(0),
+			reason: z.string().optional()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(PROMOTE_OTA_RELEASE, vars)).promoteOtaRelease));
+	server.registerTool("rollback_ota_channel", {
+		title: "rollbackOtaChannel",
+		description: "Roll a channel back to a previously published release. Requires a reason and the observed generation.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			releaseId: z.string(),
+			channel: z.string(),
+			expectedGeneration: z.number().int().min(0),
+			reason: z.string()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(ROLLBACK_OTA_CHANNEL, vars)).rollbackOtaChannel));
+	server.registerTool("create_ota_channel", {
+		title: "createOtaChannel",
+		description: "createOtaChannel for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			name: z.string()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(CREATE_OTA_CHANNEL, vars)).createOtaChannel));
+	server.registerTool("delete_ota_channel", {
+		title: "deleteOtaChannel",
+		description: "deleteOtaChannel for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			channelId: z.string()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(DELETE_OTA_CHANNEL, vars)).deleteOtaChannel));
+	server.registerTool("create_ota_delivery_key", {
+		title: "createOtaDeliveryKey",
+		description: "Create a scoped read-only delivery credential. Returns the plaintext secret once; never use it as a management API key.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			name: z.string(),
+			allowedChannelIds: z.array(z.string()).min(1).max(50),
+			expiresAt: z.string().optional()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(CREATE_OTA_DELIVERY_KEY, vars)).createOtaDeliveryKey));
+	server.registerTool("revoke_ota_delivery_key", {
+		title: "revokeOtaDeliveryKey",
+		description: "revokeOtaDeliveryKey for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			keyId: z.string()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(REVOKE_OTA_DELIVERY_KEY, vars)).revokeOtaDeliveryKey));
+	server.registerTool("pin_ota_release", {
+		title: "pinOtaRelease",
+		description: "pinOtaRelease for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			releaseId: z.string(),
+			pinned: z.boolean()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(PIN_OTA_RELEASE, vars)).pinOtaRelease));
+	server.registerTool("delete_ota_release", {
+		title: "deleteOtaRelease",
+		description: "deleteOtaRelease for the specified project and distribution.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			releaseId: z.string()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(DELETE_OTA_RELEASE, vars)).deleteOtaRelease));
+	server.registerTool("preview_ota_asset", {
+		title: "Preview OTA asset",
+		description: "Read a READY asset through management authentication before publication. Requires translator access.",
+		inputSchema: {
+			projectId: z.string(),
+			distributionId: z.string(),
+			releaseId: z.string(),
+			assetId: z.string()
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(OTA_PREVIEW_ASSET, vars)).otaPreviewAsset));
+}
+//#endregion
+//#region src/tools/analytics.ts
+function registerAnalyticsTools(server, gql) {
+	server.registerTool("project_analytics", {
+		title: "Project analytics",
+		description: "Real-time quality + progress metrics for a project (per-locale progress, open issues).",
+		inputSchema: { projectId: z.string() },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId }) => jsonResult((await gql.request(PROJECT_ANALYTICS, { projectId })).projectAnalytics));
+	server.registerTool("cost_analytics", {
+		title: "Cost analytics",
+		description: "LLM token/cost time-series and per-model breakdown over a window (default 30 days).",
+		inputSchema: {
+			projectId: z.string().optional(),
+			days: z.number().int().min(1).max(365).optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(COST_ANALYTICS, vars)).costAnalytics));
+	server.registerTool("usage", {
+		title: "Org usage & plan",
+		description: "Organization plan, hosted words and seat usage.",
+		inputSchema: {},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async () => jsonResult((await gql.request(USAGE)).usage));
+	server.registerTool("locale_progress", {
+		title: "Locale progress",
+		description: "Progress counts for one locale: total / untranslated / autoTranslated / humanApproved. The `untranslated` count drives the batch threshold (see get_config).",
+		inputSchema: {
+			projectId: z.string(),
+			localeId: z.string()
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(LOCALE_PROGRESS, vars)).localeProgress));
+}
+//#endregion
+//#region src/tools/config.ts
+function registerConfigTools(server, gql) {
+	server.registerTool("get_config", {
+		title: "Get Syntholoc config",
+		description: "Server metadata incl. `maxBulkSize` — the max keys per LLM batch. Use it as the auto-translate threshold: translate proactively only when pending untranslated keys reach this number; otherwise ask the user (an explicit translate request always runs).",
+		inputSchema: {},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async () => jsonResult((await gql.request(APP_INFO)).appInfo));
+}
+//#endregion
+//#region src/tools/git.ts
+/** One Crowdin-style file mapping: a source glob/path + its per-locale translation pattern. */
+const fileMapping = z.object({
+	source: z.string().describe("Source file path or glob, e.g. \"messages/en.json\" or \"locales/en/*.json\"."),
+	translation: z.string().describe("Translation pattern with Crowdin placeholders, e.g. \"messages/%two_letters_code%/%original_file_name%\" or \"locales/%locale%/%original_file_name%\"."),
+	languagesMapping: z.record(z.string(), z.record(z.string(), z.string())).optional().describe("Crowdin `languages_mapping`: per-placeholder, per-locale path overrides. Keyed by placeholder name without % (e.g. \"two_letters_code\", \"locale\"), then by locale code, to the on-disk replacement. E.g. { \"two_letters_code\": { \"zh-CN\": \"cn\" } } writes Chinese under \"cn\" instead of \"zh\".")
+});
+function registerGitTools(server, gql) {
+	server.registerTool("list_repositories", {
+		title: "List repositories",
+		description: "Lists git repositories connected to a project.",
+		inputSchema: { projectId: z.string() },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId }) => jsonResult((await gql.request(LIST_REPOSITORIES, { projectId })).repositories));
+	server.registerTool("get_github_app_install_url", {
+		title: "GitHub App install URL",
+		description: "Returns whether the Syntholoc GitHub App is available and a signed install URL for this project. GitHub App connect flow, step 1: give this URL to the user to open in a browser and authorize Syntholoc on the repositories they want (this authorize click cannot be automated). After they finish, call `list_github_installations` to see the new installation. If `enabled` is false, the server has no GitHub App configured — fall back to the token (PAT) path via `connect_repository`.",
+		inputSchema: { projectId: z.string() },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId }) => jsonResult((await gql.request(GITHUB_APP, { projectId })).githubApp));
+	server.registerTool("list_github_installations", {
+		title: "List GitHub installations",
+		description: "Lists GitHub App installations available to the active organization. GitHub App connect flow, step 2: run this after the user authorized the App (see `get_github_app_install_url`) to get the `installationId` to pass to `list_github_installation_repos` and `connect_repository`.",
+		inputSchema: { projectId: z.string() },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId }) => jsonResult((await gql.request(GITHUB_INSTALLATIONS, { projectId })).githubInstallations));
+	server.registerTool("list_github_installation_repos", {
+		title: "List installation repositories",
+		description: "Lists the repositories Syntholoc can access through a GitHub App installation. GitHub App connect flow, step 3: pick the target repo (its `fullName` and `defaultBranch`) before calling `connect_repository` with the same `installationId`.",
+		inputSchema: {
+			projectId: z.string(),
+			installationId: z.number().int().describe("From `list_github_installations`.")
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, installationId }) => jsonResult((await gql.request(GITHUB_INSTALLATION_REPOS, {
+		projectId,
+		installationId
+	})).githubInstallationRepos));
+	server.registerTool("connect_repository", {
+		title: "Connect repository",
+		description: "Connects a git repository to the project so syncs can pull source strings and push translation PRs. Provide EITHER `installationId` (GitHub App mode — after the browser authorize flow: `get_github_app_install_url` → `list_github_installations` → `list_github_installation_repos`) OR `token` (PAT mode — a personal access token with repo read + pull-request scope; works for GitHub, GitLab and Bitbucket, no browser needed). Mappings come from the repo's `.syntholoc/config.json` when present (the source of truth); `files`/`paths` here are an optional fallback used only when that file is absent. After connecting, call `sync_repository` to import all source strings at once.",
+		inputSchema: {
+			projectId: z.string(),
+			provider: z.enum([
+				"GITHUB",
+				"GITLAB",
+				"BITBUCKET"
+			]).default("GITHUB"),
+			fullName: z.string().describe("owner/repo, e.g. \"acme/webapp\"."),
+			branch: z.string().optional().describe("Source branch (default \"main\")."),
+			files: z.array(fileMapping).optional().describe("Crowdin-style source→translation mappings. Fallback only — an in-repo `.syntholoc/config.json` wins."),
+			paths: z.array(z.string()).optional().describe("Simple mode: source file paths/globs to track (use instead of `files`). Fallback for in-repo config."),
+			installationId: z.number().int().optional().describe("GitHub App installation id. Mutually exclusive with `token`."),
+			token: z.string().optional().describe("Access token (PAT mode), stored encrypted. Mutually exclusive with `installationId`."),
+			translationBranch: z.string().optional().describe("Branch translations are committed to (default l10n_<branch>)."),
+			prTargetBranch: z.string().optional().describe("Branch translation PRs target (default = branch)."),
+			autoSyncEnabled: z.boolean().optional().describe("Enable scheduled auto-sync.")
+		},
+		annotations: { openWorldHint: true }
+	}, async ({ projectId, ...input }) => jsonResult((await gql.request(CONNECT_REPOSITORY, {
+		projectId,
+		input
+	})).connectRepository));
+	server.registerTool("update_repository", {
+		title: "Update repository",
+		description: "Updates an already-connected repository in place — no disconnect/reconnect, stored credentials and webhooks are preserved. Use it for integration settings (source `branch`, translation/PR branches, `pushSources`, auto-sync), and for `files`/`paths` only as the DB fallback. IMPORTANT: to change file MAPPINGS, prefer editing the repo's `.syntholoc/config.json` and opening a PR — that file is the source of truth and, when present, overrides `files`/`paths` here (they are ignored). So do NOT use this tool to change mappings of a config-managed repo; edit the file, open a PR, and after it merges call `sync_repository`. Only the fields you pass are changed.",
+		inputSchema: {
+			projectId: z.string(),
+			repositoryId: z.string(),
+			branch: z.string().optional().describe("Source branch."),
+			files: z.array(fileMapping).optional().describe("Crowdin-style source→translation mappings (replaces existing)."),
+			paths: z.array(z.string()).optional().describe("Simple mode: source file paths/globs to track (replaces existing; use instead of `files`)."),
+			translationBranch: z.string().optional().describe("Branch translations are committed to."),
+			prTargetBranch: z.string().optional().describe("Branch translation PRs target."),
+			pushSources: z.boolean().optional().describe("Rewrite the source file(s) in the repo from in-app keys."),
+			autoSyncEnabled: z.boolean().optional().describe("Enable scheduled auto-sync."),
+			syncIntervalHours: z.number().int().optional().describe("Auto-sync interval in hours.")
+		},
+		annotations: { openWorldHint: true }
+	}, async ({ projectId, repositoryId, ...input }) => jsonResult((await gql.request(UPDATE_REPOSITORY, {
+		projectId,
+		id: repositoryId,
+		input
+	})).updateRepository));
+	server.registerTool("disconnect_repository", {
+		title: "Disconnect repository",
+		description: "Removes the link to a connected repository and its stored credentials. The repository itself is not affected. Destructive — confirm with the user first.",
+		inputSchema: {
+			projectId: z.string(),
+			repositoryId: z.string()
+		},
+		annotations: {
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, repositoryId }) => jsonResult((await gql.request(DISCONNECT_REPOSITORY, {
+		projectId,
+		id: repositoryId
+	})).disconnectRepository));
+	server.registerTool("sync_repository", {
+		title: "Sync repository",
+		description: "Queues an immediate sync of a connected repository (pull → translate → PR).",
+		inputSchema: {
+			projectId: z.string(),
+			repositoryId: z.string()
+		},
+		annotations: { openWorldHint: true }
+	}, async ({ projectId, repositoryId }) => jsonResult((await gql.request(SYNC_REPOSITORY, {
+		projectId,
+		id: repositoryId
+	})).syncRepository));
+	server.registerTool("push_translations", {
+		title: "Push translations (PR)",
+		description: "Queues write-back of a locale: export approved translations and open a PR.",
+		inputSchema: {
+			projectId: z.string(),
+			repositoryId: z.string(),
+			localeId: z.string()
+		},
+		annotations: { openWorldHint: true }
+	}, async (vars) => jsonResult((await gql.request(PUSH_TRANSLATIONS, vars)).pushTranslations));
+	server.registerTool("pull_translations", {
+		title: "Pull translations",
+		description: "Queues a pull of translation files from the connected repo, importing them per locale. Returns the tracking job ids — the import itself runs in the background. `autoApprove` lands them as APPROVED; `conflict` is OVERWRITE | SKIP_EXISTING | KEEP_APPROVED.",
+		inputSchema: {
+			projectId: z.string(),
+			repositoryId: z.string(),
+			autoApprove: z.boolean().default(false),
+			conflict: z.enum([
+				"OVERWRITE",
+				"SKIP_EXISTING",
+				"KEEP_APPROVED"
+			]).default("OVERWRITE")
+		},
+		annotations: { openWorldHint: true }
+	}, async ({ projectId, repositoryId, autoApprove, conflict }) => jsonResult((await gql.request(PULL_TRANSLATIONS, {
+		projectId,
+		repositoryId,
+		input: {
+			autoApprove,
+			conflict
+		}
+	})).pullTranslations));
+}
+//#endregion
+//#region src/tools/glossary.ts
+function registerGlossaryTools(server, gql) {
+	server.registerTool("list_glossary", {
+		title: "List glossary terms",
+		description: "Lists glossary terms (project-scoped if projectId given, else org-wide).",
+		inputSchema: {
+			projectId: z.string().optional(),
+			skip: z.number().int().min(0).default(0),
+			take: z.number().int().min(1).max(100).default(25)
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(LIST_GLOSSARY, vars)).glossaryTerms));
+	server.registerTool("upsert_glossary_term", {
+		title: "Create or update glossary term",
+		description: "Creates a glossary term, or updates it when `termId` is given. `translations` is a per-locale map, e.g. {\"de-DE\":\"…\"}. `forbidden` lists disallowed renderings.",
+		inputSchema: {
+			termId: z.string().optional().describe("Provide to update an existing term"),
+			projectId: z.string().optional().describe("Project scope; omit for org-wide (create only)"),
+			term: z.string().optional(),
+			description: z.string().optional(),
+			partOfSpeech: z.string().optional(),
+			doNotTranslate: z.boolean().optional(),
+			forbidden: z.array(z.string()).optional(),
+			translations: z.record(z.string(), z.string()).optional()
+		},
+		annotations: {
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, async ({ termId, projectId, ...rest }) => {
+		if (termId) return jsonResult((await gql.request(UPDATE_GLOSSARY_TERM, {
+			id: termId,
+			input: rest
+		})).updateGlossaryTerm);
+		if (!rest.term) throw new Error("`term` is required when creating a glossary term");
+		return jsonResult((await gql.request(CREATE_GLOSSARY_TERM, { input: {
+			term: rest.term,
+			...rest,
+			projectId
+		} })).createGlossaryTerm);
+	});
+	server.registerTool("delete_glossary_term", {
+		title: "Delete glossary term",
+		description: "Deletes a glossary term. Destructive — confirm first.",
+		inputSchema: { termId: z.string() },
+		annotations: {
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async ({ termId }) => jsonResult((await gql.request(DELETE_GLOSSARY_TERM, { id: termId })).deleteGlossaryTerm));
+	server.registerTool("suggest_glossary_terms", {
+		title: "Suggest glossary terms",
+		description: "AI-suggested glossary terms extracted from the project source strings.",
+		inputSchema: { projectId: z.string() },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId }) => jsonResult((await gql.request(SUGGEST_GLOSSARY_TERMS, { projectId })).suggestGlossaryTerms));
+}
+//#endregion
+//#region src/tools/jobs.ts
+function registerJobTools(server, gql) {
+	server.registerTool("get_job", {
+		title: "Get job",
+		description: "Status, progress, token usage and cost of a background job by id.",
+		inputSchema: {
+			jobId: z.string(),
+			projectId: z.string()
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ jobId, projectId }) => jsonResult((await gql.request(GET_JOB, {
+		id: jobId,
+		projectId
+	})).job));
+	server.registerTool("list_jobs", {
+		title: "List jobs",
+		description: "Recent background jobs for a project (translate / QA / git sync).",
+		inputSchema: {
+			projectId: z.string(),
+			skip: z.number().int().min(0).default(0),
+			take: z.number().int().min(1).max(100).default(25)
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(LIST_JOBS, vars)).jobs));
+	server.registerTool("wait_for_job", {
+		title: "Wait for job",
+		description: "Polls a job until it reaches a terminal state (COMPLETED/FAILED/CANCELLED) or the timeout elapses, then returns its final detail. Use after translate/QA to follow a run.",
+		inputSchema: {
+			jobId: z.string(),
+			projectId: z.string(),
+			timeoutSec: z.number().int().min(1).max(900).default(180),
+			pollIntervalSec: z.number().int().min(1).max(30).default(2)
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ jobId, projectId, timeoutSec, pollIntervalSec }) => {
+		const { job, timedOut } = await waitForJob(gql, projectId, jobId, {
+			timeoutSec,
+			pollIntervalSec
+		});
+		return jsonResult({
+			...job,
+			timedOut
+		});
+	});
+}
+//#endregion
+//#region src/tools/keys.ts
+const FORMATS$1 = [
+	"JSON",
+	"YAML",
+	"MARKDOWN",
+	"MDX",
+	"CSV",
+	"PO",
+	"XLIFF",
+	"ANDROID_XML",
+	"IOS_STRINGS",
+	"IOS_STRINGSDICT",
+	"IOS_XCSTRINGS",
+	"NJK"
+];
+/** Document formats: segments only have an identity within a file, so the path is required. */
+const DOCUMENT_FORMATS$1 = /* @__PURE__ */ new Set(["MARKDOWN", "MDX"]);
+function registerKeyTools(server, gql) {
+	server.registerTool("list_keys", {
+		title: "List keys",
+		description: "Lists source keys. With `localeId` + `status` (untranslated | flagged | approved) the result `totalCount` is the pending count for that status — use it for the batch threshold.",
+		inputSchema: {
+			projectId: z.string(),
+			localeId: z.string().optional(),
+			status: z.enum([
+				"untranslated",
+				"flagged",
+				"approved"
+			]).optional(),
+			search: z.string().optional(),
+			skip: z.number().int().min(0).default(0),
+			take: z.number().int().min(1).max(200).default(25)
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(LIST_KEYS, vars)).keys));
+	server.registerTool("upsert_keys", {
+		title: "Upsert keys (bulk)",
+		description: "Bulk-upserts source keys by name (delta sync from local i18n files). Keys not listed are left untouched. Returns added/updated/unchanged counts; set `dryRun` to preview.",
+		inputSchema: {
+			projectId: z.string(),
+			keys: z.array(z.object({
+				key: z.string(),
+				sourceText: z.string(),
+				context: z.string().optional(),
+				maxLength: z.number().int().positive().optional()
+			})).min(1),
+			dryRun: z.boolean().default(false)
+		},
+		annotations: {
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, keys, dryRun }) => jsonResult((await gql.request(UPSERT_KEYS, {
+		projectId,
+		input: keys,
+		dryRun
+	})).upsertKeys));
+	server.registerTool("update_key", {
+		title: "Update key",
+		description: "Updates a single key (source text, context, max length).",
+		inputSchema: {
+			projectId: z.string(),
+			keyId: z.string(),
+			sourceText: z.string().optional(),
+			context: z.string().optional(),
+			maxLength: z.number().int().positive().optional()
+		},
+		annotations: {
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, keyId, ...input }) => jsonResult((await gql.request(UPDATE_KEY, {
+		projectId,
+		id: keyId,
+		input
+	})).updateKey));
+	server.registerTool("delete_key", {
+		title: "Delete key",
+		description: "Deletes a key and its translations. Destructive — confirm first.",
+		inputSchema: {
+			projectId: z.string(),
+			keyId: z.string()
+		},
+		annotations: {
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, keyId }) => jsonResult((await gql.request(DELETE_KEY, {
+		projectId,
+		id: keyId
+	})).deleteKey));
+	server.registerTool("import_source_strings", {
+		title: "Import source strings",
+		description: "Imports source strings from ONE file (paste the raw content) and returns the diff summary. For initial setup of a repo-hosted project, PREFER connecting the repo and running `sync_repository` — it imports every source file server-side in one pass; use this tool only for file-based projects with no Git integration, or for one-off single-file imports. For a multi-file / namespaced project (a file per namespace, e.g. messages/en/home.json), pass `keyPrefix` (the namespace, e.g. \"home\") so keys become `home.title` and files with overlapping top-level keys do not collide — call once per file. Use `dryRun` to preview. For MARKDOWN and MDX `sourceFile` is REQUIRED: the document is split into per-block segments, and without the file path a re-import cannot tell a moved paragraph from an edited one.",
+		inputSchema: {
+			projectId: z.string(),
+			content: z.string(),
+			format: z.enum(FORMATS$1),
+			keyPrefix: z.string().optional().describe("Namespace prefix, e.g. \"home\" (per-file, multi-file projects)."),
+			sourceFile: z.string().optional().describe("Real source file path, e.g. \"messages/en/home.json\" — stored for the file tree + reliable export."),
+			dryRun: z.boolean().default(false)
+		},
+		annotations: {
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, content, format, keyPrefix, sourceFile, dryRun }) => {
+		if (DOCUMENT_FORMATS$1.has(format) && !sourceFile?.trim()) return errorResult(`${format} needs a sourceFile — a document's segments only have an identity within a file.`);
+		return jsonResult((await gql.request(IMPORT_SOURCE_STRINGS, {
+			projectId,
+			input: {
+				content,
+				format,
+				keyPrefix,
+				sourceFile,
+				dryRun
+			}
+		})).importSourceStrings);
+	});
+}
+//#endregion
+//#region ../../packages/shared/src/locales.ts
+const STARTER_LOCALES = [
+	{
+		code: "ar",
+		name: "Arabic",
+		nativeName: "العربية",
+		rtl: true
+	},
+	{
+		code: "az",
+		name: "Azerbaijani",
+		nativeName: "Azərbaycan"
+	},
+	{
+		code: "be",
+		name: "Belarusian",
+		nativeName: "Беларуская"
+	},
+	{
+		code: "bn",
+		name: "Bengali",
+		nativeName: "বাংলা"
+	},
+	{
+		code: "cs",
+		name: "Czech",
+		nativeName: "Čeština"
+	},
+	{
+		code: "de",
+		name: "German",
+		nativeName: "Deutsch"
+	},
+	{
+		code: "el",
+		name: "Greek",
+		nativeName: "Ελληνικά"
+	},
+	{
+		code: "en",
+		name: "English",
+		nativeName: "English"
+	},
+	{
+		code: "es",
+		name: "Spanish",
+		nativeName: "Español"
+	},
+	{
+		code: "es-419",
+		name: "Spanish (Latin America)",
+		nativeName: "Español (Latinoamérica)"
+	},
+	{
+		code: "fa",
+		name: "Persian",
+		nativeName: "فارسی",
+		rtl: true
+	},
+	{
+		code: "fr",
+		name: "French",
+		nativeName: "Français"
+	},
+	{
+		code: "hi",
+		name: "Hindi",
+		nativeName: "हिन्दी"
+	},
+	{
+		code: "hy",
+		name: "Armenian",
+		nativeName: "Հայերեն"
+	},
+	{
+		code: "id",
+		name: "Indonesian",
+		nativeName: "Bahasa Indonesia"
+	},
+	{
+		code: "it",
+		name: "Italian",
+		nativeName: "Italiano"
+	},
+	{
+		code: "ja",
+		name: "Japanese",
+		nativeName: "日本語"
+	},
+	{
+		code: "ka",
+		name: "Georgian",
+		nativeName: "ქართული"
+	},
+	{
+		code: "kk",
+		name: "Kazakh",
+		nativeName: "Қазақ тілі"
+	},
+	{
+		code: "ko",
+		name: "Korean",
+		nativeName: "한국어"
+	},
+	{
+		code: "lv",
+		name: "Latvian",
+		nativeName: "Latviešu"
+	},
+	{
+		code: "ms",
+		name: "Malay",
+		nativeName: "Bahasa Melayu"
+	},
+	{
+		code: "nl",
+		name: "Dutch",
+		nativeName: "Nederlands"
+	},
+	{
+		code: "pl",
+		name: "Polish",
+		nativeName: "Polski"
+	},
+	{
+		code: "pt-BR",
+		name: "Portuguese (Brazil)",
+		nativeName: "Português (Brasil)"
+	},
+	{
+		code: "pt-PT",
+		name: "Portuguese (Portugal)",
+		nativeName: "Português (Portugal)"
+	},
+	{
+		code: "ro",
+		name: "Romanian",
+		nativeName: "Română"
+	},
+	{
+		code: "ru",
+		name: "Russian",
+		nativeName: "Русский"
+	},
+	{
+		code: "sk",
+		name: "Slovak",
+		nativeName: "Slovenčina"
+	},
+	{
+		code: "sl",
+		name: "Slovenian",
+		nativeName: "Slovenščina"
+	},
+	{
+		code: "sw",
+		name: "Swahili",
+		nativeName: "Kiswahili"
+	},
+	{
+		code: "th",
+		name: "Thai",
+		nativeName: "ไทย"
+	},
+	{
+		code: "tl",
+		name: "Filipino",
+		nativeName: "Filipino"
+	},
+	{
+		code: "tr",
+		name: "Turkish",
+		nativeName: "Türkçe"
+	},
+	{
+		code: "uk",
+		name: "Ukrainian",
+		nativeName: "Українська"
+	},
+	{
+		code: "ur",
+		name: "Urdu",
+		nativeName: "اردو",
+		rtl: true
+	},
+	{
+		code: "uz",
+		name: "Uzbek",
+		nativeName: "Oʻzbek"
+	},
+	{
+		code: "vi",
+		name: "Vietnamese",
+		nativeName: "Tiếng Việt"
+	},
+	{
+		code: "zh-CN",
+		name: "Chinese (Simplified)",
+		nativeName: "简体中文"
+	},
+	{
+		code: "zh-TW",
+		name: "Chinese (Traditional)",
+		nativeName: "繁體中文"
+	}
+];
+STARTER_LOCALES.map((l) => l.code);
+const STARTER_BY_CODE = new Map(STARTER_LOCALES.map((l) => [l.code, l]));
+/** Looks up a starter-catalog locale by BCP-47 code. */
+function findStarterLocale(code) {
+	return STARTER_BY_CODE.get(code);
+}
+//#endregion
+//#region ../../packages/shared/src/locale-resolve.ts
+/**
+* Resolves a user- or agent-supplied locale code to a canonical, unambiguous
+* BCP-47 tag before it is persisted as a project target locale.
+*
+* Motivation: `add_locale` / `seed_starter_locales` used to accept ANY string
+* verbatim, so an LLM setting up sync could create a target like `pt` (a valid
+* ISO-639 language, but ambiguous — Brazil vs Portugal) or `cn` (not a real
+* BCP-47 tag at all). Both then rendered as raw codes in the UI. This resolver
+* gives callers actionable feedback: normalize known aliases/casing, and reject
+* ambiguous macro-languages so the caller must pick a concrete variant.
+*/
+/**
+* Common non-BCP-47 shorthands people and LLMs reach for, mapped to the
+* catalog code they almost certainly mean. Keyed by lower-cased input.
+* Kept deliberately conservative — only unambiguous, well-known cases.
+*/
+const ALIASES = {
+	cn: "zh-CN",
+	"zh-hans": "zh-CN",
+	"zh-hant": "zh-TW",
+	jp: "ja",
+	kr: "ko",
+	ua: "uk",
+	cz: "cs",
+	gr: "el",
+	iw: "he",
+	in: "id"
+};
+/** Catalog codes grouped by their primary language subtag (e.g. pt → [pt-BR, pt-PT]). */
+const VARIANTS_BY_LANG = (() => {
+	const map = /* @__PURE__ */ new Map();
+	for (const { code } of STARTER_LOCALES) {
+		const lang = code.split("-")[0].toLowerCase();
+		(map.get(lang) ?? map.set(lang, []).get(lang)).push(code);
+	}
+	return map;
+})();
+/** Canonicalizes casing/structure via the runtime CLDR (pt-br → pt-BR). */
+function canonicalize(input) {
+	try {
+		return Intl.getCanonicalLocales(input)[0] ?? null;
+	} catch {
+		return null;
+	}
+}
+/** Whether a structurally-valid tag names a language the runtime actually knows. */
+function isRealLanguage(code) {
+	try {
+		return !!new Intl.DisplayNames(["en"], {
+			type: "language",
+			fallback: "none"
+		}).of(code);
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolves a locale code to one of four outcomes. Callers should persist the
+* resolved `code` for `ok`/`normalized`, and reject `ambiguous`/`unknown` with
+* the provided message (and candidate list, for ambiguous).
+*/
+function resolveLocaleCode(raw) {
+	const input = raw.trim();
+	if (!input) return {
+		status: "unknown",
+		input: raw,
+		message: "Empty locale code."
+	};
+	const alias = ALIASES[input.toLowerCase()];
+	if (alias) return {
+		status: "normalized",
+		code: alias,
+		from: input,
+		reason: `mapped "${input}" to catalog code "${alias}"`
+	};
+	const canonical = canonicalize(input);
+	if (!canonical) return {
+		status: "unknown",
+		input,
+		message: `"${input}" is not a valid BCP-47 locale code.`
+	};
+	if (findStarterLocale(canonical)) return canonical === input ? {
+		status: "ok",
+		code: canonical
+	} : {
+		status: "normalized",
+		code: canonical,
+		from: input,
+		reason: `casing normalized to "${canonical}"`
+	};
+	const lang = canonical.split("-")[0].toLowerCase();
+	const hasRegionOrScript = canonical.includes("-");
+	const variants = VARIANTS_BY_LANG.get(lang) ?? [];
+	if (!hasRegionOrScript) {
+		if (variants.length > 1) return {
+			status: "ambiguous",
+			input,
+			candidates: variants,
+			message: `"${input}" is ambiguous — the catalog has ${variants.join(", ")}. Pick one.`
+		};
+		if (variants.length === 1) return {
+			status: "normalized",
+			code: variants[0],
+			from: input,
+			reason: `expanded "${input}" to "${variants[0]}"`
+		};
+		return isRealLanguage(canonical) ? {
+			status: "ok",
+			code: canonical
+		} : {
+			status: "unknown",
+			input,
+			message: `"${input}" is not a recognized language.`
+		};
+	}
+	if (!isRealLanguage(canonical)) return {
+		status: "unknown",
+		input,
+		message: `"${input}" is not a valid locale.`
+	};
+	return canonical === input ? {
+		status: "ok",
+		code: canonical
+	} : {
+		status: "normalized",
+		code: canonical,
+		from: input,
+		reason: `canonicalized to "${canonical}"`
+	};
+}
+/** Resolves a batch of codes, partitioning them into usable / normalized / rejected. */
+function resolveLocaleCodes(raw) {
+	const out = {
+		codes: [],
+		normalized: [],
+		rejected: []
+	};
+	const seen = /* @__PURE__ */ new Set();
+	for (const code of raw) {
+		const res = resolveLocaleCode(code);
+		if (res.status === "ambiguous") out.rejected.push({
+			input: res.input,
+			message: res.message,
+			candidates: res.candidates
+		});
+		else if (res.status === "unknown") out.rejected.push({
+			input: res.input,
+			message: res.message
+		});
+		else {
+			if (res.status === "normalized") out.normalized.push({
+				from: res.from,
+				code: res.code,
+				reason: res.reason
+			});
+			if (!seen.has(res.code)) {
+				seen.add(res.code);
+				out.codes.push(res.code);
+			}
+		}
+	}
+	return out;
+}
+//#endregion
+//#region ../../packages/shared/src/constants.ts
+/**
+* Every tier, mirroring the `OrgPlan` enum in the Prisma schema. This package
+* has no dependency on `@syntholoc/db` (it is imported by the CLI and the web
+* app, neither of which should pull in a database client), so the list is
+* restated here and pinned to the real enum by a compile-time assertion in the
+* API — see `apps/api/src/common/plan.assert.ts`.
+*/
+const ORG_PLANS = [
+	"FREE",
+	"PRO",
+	"ENTERPRISE"
+];
+/**
+* True when the organization's plan may use metered features (site scanning,
+* the static code index).
+*
+* An exhaustive switch, not a membership test against a list of paid tiers: a
+* tier added to the enum and forgotten here becomes a type error rather than
+* silently free. That matters in the direction it fails — a new paid tier that
+* quietly reads as unpaid locks paying customers out of what they bought.
+*/
+function isPaidPlan(plan) {
+	switch (plan) {
+		case "PRO":
+		case "ENTERPRISE": return true;
+		case "FREE": return false;
+		default: return false;
+	}
+}
+ORG_PLANS.filter(isPaidPlan);
+//#endregion
+//#region src/tools/locales.ts
+function registerLocaleTools(server, gql) {
+	server.registerTool("list_locales", {
+		title: "List locales",
+		description: "Lists the target locales configured for a project.",
+		inputSchema: { projectId: z.string() },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId }) => jsonResult((await gql.request(LIST_LOCALES, { projectId })).locales));
+	server.registerTool("add_locale", {
+		title: "Add locale",
+		description: "Adds ONE target locale to a project. To add several at once, prefer seed_starter_locales (one call for the whole list). Codes are validated: aliases/casing are normalized (e.g. \"cn\" → \"zh-CN\"), and ambiguous macro-languages (e.g. \"pt\", \"zh\") are rejected with the concrete variants to choose from (pt-BR / pt-PT, zh-CN / zh-TW).",
+		inputSchema: {
+			projectId: z.string(),
+			code: z.string().optional().describe("BCP-47 code, e.g. \"de-DE\" or \"ru\". Alias: `locale`."),
+			locale: z.string().optional().describe("Alias for `code`."),
+			name: z.string().optional(),
+			formality: z.string().optional(),
+			gender: z.string().optional(),
+			variant: z.string().optional()
+		},
+		annotations: { openWorldHint: true }
+	}, async ({ projectId, code, locale, name, formality, gender, variant }) => {
+		const resolvedCode = code ?? locale;
+		if (!resolvedCode) return jsonResult({ error: "Missing locale code. Pass `code` (BCP-47, e.g. \"de-DE\" or \"ru\"). To add several locales at once, use seed_starter_locales with a `codes` array." });
+		const res = resolveLocaleCode(resolvedCode);
+		if (res.status === "ambiguous") return jsonResult({
+			error: res.message,
+			hint: `Retry add_locale with one of: ${res.candidates.join(", ")}.`,
+			candidates: res.candidates
+		});
+		if (res.status === "unknown") return jsonResult({
+			error: res.message,
+			hint: "Use a valid BCP-47 code, e.g. \"de-DE\" or \"zh-CN\"."
+		});
+		const input = {
+			code: res.code,
+			name,
+			formality,
+			gender,
+			variant
+		};
+		const added = (await gql.request(ADD_LOCALE, {
+			projectId,
+			input
+		})).addLocale;
+		return res.status === "normalized" ? jsonResult({
+			...added,
+			note: `Interpreted "${res.from}" as "${res.code}" (${res.reason}).`
+		}) : jsonResult(added);
+	});
+	server.registerTool("seed_starter_locales", {
+		title: "Seed starter locales",
+		description: "Adds MULTIPLE target locales in one call — pass `codes` (BCP-47, e.g. [\"ru\",\"de-DE\",\"fr\"]), or omit for a common starter set. Prefer this over repeated add_locale calls. Codes are validated as a batch: if any are ambiguous (e.g. \"pt\", \"zh\") or invalid, NONE are added and the response lists what to fix; aliases like \"cn\" are normalized to \"zh-CN\".",
+		inputSchema: {
+			projectId: z.string(),
+			codes: z.array(z.string()).optional().describe("BCP-47 codes to add, e.g. [\"ru\",\"de-DE\",\"fr\"].")
+		},
+		annotations: { openWorldHint: true }
+	}, async ({ projectId, codes }) => {
+		if (codes && codes.length > 0) {
+			const resolved = resolveLocaleCodes(codes);
+			if (resolved.rejected.length > 0) return jsonResult({
+				error: "Some locale codes are ambiguous or invalid; nothing was added.",
+				hint: "Fix the codes below and retry. For ambiguous ones, pick a listed candidate.",
+				rejected: resolved.rejected
+			});
+			const seeded = (await gql.request(SEED_STARTER_LOCALES, {
+				projectId,
+				codes: resolved.codes
+			})).seedStarterLocales;
+			return resolved.normalized.length > 0 ? jsonResult({
+				locales: seeded,
+				normalized: resolved.normalized
+			}) : jsonResult(seeded);
+		}
+		return jsonResult((await gql.request(SEED_STARTER_LOCALES, {
+			projectId,
+			codes
+		})).seedStarterLocales);
+	});
+	server.registerTool("remove_locale", {
+		title: "Remove locale",
+		description: "Removes a target locale and its translations. Destructive — confirm first.",
+		inputSchema: {
+			projectId: z.string(),
+			localeId: z.string()
+		},
+		annotations: {
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, localeId }) => jsonResult((await gql.request(REMOVE_LOCALE, {
+		projectId,
+		id: localeId
+	})).removeLocale));
+}
+//#endregion
+//#region src/tools/projects.ts
+function registerProjectTools(server, gql) {
+	server.registerTool("list_organizations", {
+		title: "List organizations",
+		description: "Organizations you belong to (id, name, slug, your role). To act in a specific org, set the `syntholoc-org-id` request header (hosted transport); otherwise the earliest org is used.",
+		inputSchema: {},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async () => jsonResult((await gql.request(MY_ORGANIZATIONS)).myProjects.map((g) => ({
+		...g.organization,
+		viewerRole: g.viewerRole
+	}))));
+	server.registerTool("list_projects", {
+		title: "List projects",
+		description: "Lists localization projects in the active organization (paginated).",
+		inputSchema: {
+			skip: z.number().int().min(0).default(0),
+			take: z.number().int().min(1).max(100).default(25)
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ skip, take }) => jsonResult((await gql.request(LIST_PROJECTS, {
+		skip,
+		take
+	})).projects));
+	server.registerTool("get_project", {
+		title: "Get project",
+		description: "Project settings plus analytics, including per-locale progress with the `untranslated` count used to decide the batch threshold (see get_config).",
+		inputSchema: { projectId: z.string() },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId }) => jsonResult(await gql.request(GET_PROJECT, { id: projectId })));
+	server.registerTool("create_project", {
+		title: "Create project",
+		description: "Creates a localization project. `sourceLocale` defaults to \"en\".",
+		inputSchema: {
+			name: z.string(),
+			sourceLocale: z.string().default("en"),
+			description: z.string().optional(),
+			context: z.string().optional(),
+			requireReview: z.boolean().optional(),
+			qaCriticEnabled: z.boolean().optional()
+		},
+		annotations: { openWorldHint: true }
+	}, async (input) => jsonResult((await gql.request(CREATE_PROJECT, { input })).createProject));
+	server.registerTool("update_project", {
+		title: "Update project",
+		description: "Updates project settings (name, source locale, review/QA flags, context).",
+		inputSchema: {
+			projectId: z.string(),
+			name: z.string().optional(),
+			sourceLocale: z.string().optional(),
+			description: z.string().optional(),
+			context: z.string().optional(),
+			requireReview: z.boolean().optional(),
+			qaCriticEnabled: z.boolean().optional(),
+			exportApprovedOnly: z.boolean().optional(),
+			sortKeysAlphabetically: z.boolean().optional(),
+			status: z.string().optional()
+		},
+		annotations: {
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, ...input }) => jsonResult((await gql.request(UPDATE_PROJECT, {
+		id: projectId,
+		input
+	})).updateProject));
+}
+//#endregion
+//#region src/generated/input-schemas.ts
+const isDefinedNonNullAny = (v) => v !== void 0 && v !== null;
+z.any().refine((v) => isDefinedNonNullAny(v));
+z.enum([
+	"DYNAMIC",
+	"NOT_CAPTURED",
+	"NOT_IN_CODE",
+	"SCREENSHOT",
+	"SERVER",
+	"TEST",
+	"UNKNOWN"
+]);
+z.enum(["ALL", "UNREVIEWED"]);
+z.enum([
+	"ALL",
+	"DRAFT",
+	"UNAPPROVED",
+	"UNTRANSLATED"
+]);
+function ConfigureProviderInputSchema() {
+	return z.object({
+		apiKey: z.string(),
+		baseUrl: z.string().nullish(),
+		defaultModel: z.string().nullish(),
+		label: z.string(),
+		type: z.string()
+	});
+}
+//#endregion
+//#region src/tools/providers.ts
+function registerProviderTools(server, gql) {
+	server.registerTool("list_llm_providers", {
+		title: "List LLM providers",
+		description: "Configured LLM providers for the org (never exposes the API key).",
+		inputSchema: {},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async () => jsonResult((await gql.request(LIST_LLM_PROVIDERS)).llmProviders));
+	server.registerTool("configure_llm_provider", {
+		title: "Configure LLM provider",
+		description: "Adds a BYOK LLM provider (APISTOCK | OPENROUTER | OPENAI | ANTHROPIC). The key is stored encrypted at rest.",
+		inputSchema: {
+			...ConfigureProviderInputSchema().shape,
+			type: z.enum([
+				"APISTOCK",
+				"OPENROUTER",
+				"OPENAI",
+				"ANTHROPIC"
+			])
+		},
+		annotations: { openWorldHint: true }
+	}, async (input) => jsonResult((await gql.request(CONFIGURE_LLM_PROVIDER, { input })).configureLlmProvider));
+}
+//#endregion
+//#region src/tools/qa.ts
+function registerQaTools(server, gql) {
+	server.registerTool("run_locale_qa", {
+		title: "Run locale QA",
+		description: "Queues an LLM QA-critic pass over a locale's non-approved translations. `scope` UNREVIEWED (default) critiques only translations not yet reviewed at their current text; ALL re-critiques every one. Returns tracking `jobIds`.",
+		inputSchema: {
+			projectId: z.string(),
+			localeId: z.string(),
+			scope: z.enum(["UNREVIEWED", "ALL"]).optional()
+		},
+		annotations: { openWorldHint: true }
+	}, async (vars) => jsonResult((await gql.request(RUN_LOCALE_QA, vars)).runLocaleQa));
+	server.registerTool("run_qa", {
+		title: "Run QA on a translation",
+		description: "Runs QA on one translation and returns its score and issues (synchronous).",
+		inputSchema: {
+			projectId: z.string(),
+			translationId: z.string()
+		},
+		annotations: { openWorldHint: true }
+	}, async (vars) => jsonResult((await gql.request(RUN_QA, vars)).runQa));
+	server.registerTool("list_qa_issues", {
+		title: "List QA issues",
+		description: "Open QA issues for a locale, plus the issue-type facets (filter tabs).",
+		inputSchema: {
+			projectId: z.string(),
+			localeId: z.string(),
+			type: z.string().optional(),
+			skip: z.number().int().min(0).default(0),
+			take: z.number().int().min(1).max(100).default(25)
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult(await gql.request(LIST_QA_ISSUES, vars)));
+}
+//#endregion
+//#region src/tools/styleguides.ts
+function registerStyleGuideTools(server, gql) {
+	server.registerTool("list_style_guides", {
+		title: "List style guides",
+		description: "Lists style guides (project-scoped if projectId given, else org-wide).",
+		inputSchema: { projectId: z.string().optional() },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId }) => jsonResult((await gql.request(LIST_STYLE_GUIDES, { projectId })).styleGuides));
+	server.registerTool("generate_style_guide", {
+		title: "Generate style guide (draft)",
+		description: "Drafts a tone/rules/prompt-fragment style guide from the project (optionally per locale). Returns a draft — persist it with create_style_guide.",
+		inputSchema: {
+			projectId: z.string(),
+			localeCode: z.string().optional()
+		},
+		annotations: { openWorldHint: true }
+	}, async ({ projectId, localeCode }) => jsonResult((await gql.request(GENERATE_STYLE_GUIDE, { input: {
+		projectId,
+		localeCode
+	} })).generateStyleGuide));
+	server.registerTool("create_style_guide", {
+		title: "Create style guide",
+		description: "Persists a style guide (tone, rules JSON, prompt fragment), project- or locale-scoped.",
+		inputSchema: {
+			name: z.string(),
+			projectId: z.string().optional(),
+			localeCode: z.string().optional(),
+			tone: z.string().optional(),
+			promptFragment: z.string().optional(),
+			rules: z.array(z.string()).optional()
+		},
+		annotations: { openWorldHint: true }
+	}, async (input) => jsonResult((await gql.request(CREATE_STYLE_GUIDE, { input })).createStyleGuide));
+}
+//#endregion
+//#region src/tools/tm.ts
+/** Translation Memory: concordance search, coverage stats, and browsing. */
+function registerTmTools(server, gql) {
+	server.registerTool("tm_search", {
+		title: "Search translation memory",
+		description: "Concordance search — the nearest prior translations for a source string in a target locale, with cosine distance (0 = identical). Scope to a project with `projectId` (includes its group siblings); omit for the whole organization. Requires an embedding-capable provider.",
+		inputSchema: {
+			sourceText: z.string(),
+			targetLocale: z.string(),
+			projectId: z.string().optional(),
+			limit: z.number().int().min(1).max(20).default(5)
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ sourceText, targetLocale, projectId, limit }) => jsonResult((await gql.request(TM_SEARCH, {
+		sourceText,
+		targetLocale,
+		projectId,
+		limit
+	})).tmSearch));
+	server.registerTool("tm_stats", {
+		title: "Translation memory stats",
+		description: "Entry counts per target locale (org-wide, or for a project with `projectId`).",
+		inputSchema: { projectId: z.string().optional() },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId }) => jsonResult((await gql.request(TM_STATS, { projectId })).tmStats));
+	server.registerTool("list_tm", {
+		title: "Browse translation memory",
+		description: "Lists stored TM entries (paginated, newest first), optionally filtered by project and locale.",
+		inputSchema: {
+			projectId: z.string().optional(),
+			targetLocale: z.string().optional(),
+			skip: z.number().int().min(0).default(0),
+			take: z.number().int().min(1).max(100).default(25)
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(TM_ENTRIES, vars)).tmEntries));
+}
+//#endregion
+//#region src/tools/translations.ts
+const FORMATS = [
+	"JSON",
+	"YAML",
+	"MARKDOWN",
+	"MDX",
+	"CSV",
+	"PO",
+	"XLIFF",
+	"ANDROID_XML",
+	"IOS_STRINGS",
+	"IOS_STRINGSDICT",
+	"IOS_XCSTRINGS",
+	"NJK"
+];
+/** Document formats: exported whole via `export_document`, imported by position. */
+const DOCUMENT_FORMATS = /* @__PURE__ */ new Set(["MARKDOWN", "MDX"]);
+function registerTranslationTools(server, gql) {
+	server.registerTool("translate_locale", {
+		title: "Translate locale",
+		description: "Queues AI translation of a locale (scope ALL | UNAPPROVED | UNTRANSLATED) and returns the tracking `jobIds`. Executes immediately and unconditionally — the batch threshold is a client-side policy for PROACTIVE syncs, not for this tool.",
+		inputSchema: {
+			projectId: z.string(),
+			localeId: z.string(),
+			scope: z.enum([
+				"ALL",
+				"UNAPPROVED",
+				"UNTRANSLATED"
+			]).default("UNTRANSLATED")
+		},
+		annotations: { openWorldHint: true }
+	}, async (vars) => jsonResult((await gql.request(TRANSLATE_LOCALE, vars)).translateLocale));
+	server.registerTool("translate_key", {
+		title: "Translate key",
+		description: "Queues AI translation of a single key into a locale. Returns tracking `jobIds`.",
+		inputSchema: {
+			projectId: z.string(),
+			keyId: z.string(),
+			localeId: z.string()
+		},
+		annotations: { openWorldHint: true }
+	}, async (vars) => jsonResult((await gql.request(TRANSLATE_KEY, vars)).translateKey));
+	server.registerTool("set_translation", {
+		title: "Set translation",
+		description: "Manually sets the translation text for a key in a locale.",
+		inputSchema: {
+			projectId: z.string(),
+			keyId: z.string(),
+			localeId: z.string(),
+			text: z.string(),
+			origin: z.string().optional()
+		},
+		annotations: {
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, keyId, localeId, text, origin }) => jsonResult((await gql.request(SET_TRANSLATION, {
+		projectId,
+		input: {
+			keyId,
+			localeId,
+			text,
+			origin
+		}
+	})).setTranslation));
+	server.registerTool("list_translations", {
+		title: "List translations",
+		description: "Lists translations for a locale with status, origin, model and QA score.",
+		inputSchema: {
+			projectId: z.string(),
+			localeId: z.string(),
+			skip: z.number().int().min(0).default(0),
+			take: z.number().int().min(1).max(200).default(25)
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult((await gql.request(LIST_TRANSLATIONS, vars)).translations));
+	server.registerTool("approve_translation", {
+		title: "Approve translation",
+		description: "Marks a translation APPROVED.",
+		inputSchema: {
+			projectId: z.string(),
+			translationId: z.string()
+		},
+		annotations: {
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, translationId }) => jsonResult((await gql.request(APPROVE_TRANSLATION, {
+		projectId,
+		id: translationId
+	})).approveTranslation));
+	server.registerTool("reject_translation", {
+		title: "Reject translation",
+		description: "Marks a translation REJECTED (queued for re-translation).",
+		inputSchema: {
+			projectId: z.string(),
+			translationId: z.string()
+		},
+		annotations: {
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, translationId }) => jsonResult((await gql.request(REJECT_TRANSLATION, {
+		projectId,
+		id: translationId
+	})).rejectTranslation));
+	server.registerTool("export_locale", {
+		title: "Export locale",
+		description: "Exports a locale to a file string in the chosen format — the basis for writing translations back into local files. Set `onlyApproved` to exclude drafts. For a multi-file project prefer `sourceFile` (the real path, e.g. \"messages/en/home.json\") to export exactly that file with file-local key names — reliable. `keyPrefix` is the legacy name-prefix heuristic. For MARKDOWN and MDX use `export_document` instead: a document is spliced into its original file, which the server reads from the connected repository.",
+		inputSchema: {
+			projectId: z.string(),
+			localeId: z.string(),
+			format: z.enum(FORMATS).default("JSON"),
+			onlyApproved: z.boolean().optional(),
+			sourceFile: z.string().optional().describe("Real source file path to export, e.g. \"messages/en/home.json\" (reliable, preferred)."),
+			keyPrefix: z.string().optional().describe("Legacy namespace prefix, e.g. \"home\".")
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => jsonResult({ content: (await gql.request(EXPORT_LOCALE, vars)).exportLocale }));
+	server.registerTool("export_document", {
+		title: "Export document locale",
+		description: "Exports one locale of a Markdown or MDX source document. Unlike `export_locale` this returns the whole translated document: the server reads the original file from the connected repository and splices the translations into it, so headings, list markers, code fences and indentation are preserved byte for byte. Segments with no translation keep their source text.",
+		inputSchema: {
+			projectId: z.string(),
+			localeId: z.string(),
+			sourceFile: z.string().describe("Path of the source document in the repository, e.g. \"docs/guide.md\"."),
+			repositoryId: z.string().optional().describe("Only needed when the project has several repositories and the path is ambiguous."),
+			onlyApproved: z.boolean().optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async (vars) => {
+		if (!vars.sourceFile.trim()) return errorResult("export_document needs a sourceFile — the path of the document in the repository.");
+		return jsonResult({ content: (await gql.request(EXPORT_DOCUMENT_LOCALE, vars)).exportDocumentLocale });
+	});
+	server.registerTool("import_translations", {
+		title: "Import translations",
+		description: "Imports ready-made translations for a locale (paste file content). `autoApprove` lands them as APPROVED; `conflict` is OVERWRITE | SKIP_EXISTING | KEEP_APPROVED; `dryRun` previews. For a multi-file / namespaced project pass `keyPrefix` (the namespace) to match prefixed source keys. For MARKDOWN and MDX `sourceFile` is REQUIRED: a translated document has translated headings, so it is matched to the source by segment position and the two must have the same structure.",
+		inputSchema: {
+			projectId: z.string(),
+			localeId: z.string(),
+			content: z.string(),
+			format: z.enum(FORMATS),
+			keyPrefix: z.string().optional().describe("Namespace prefix, e.g. \"home\" (per-file, multi-file projects)."),
+			sourceFile: z.string().optional().describe("Source file these translations belong to; REQUIRED for MARKDOWN/MDX, e.g. \"docs/guide.md\"."),
+			autoApprove: z.boolean().default(false),
+			conflict: z.enum([
+				"OVERWRITE",
+				"SKIP_EXISTING",
+				"KEEP_APPROVED"
+			]).default("OVERWRITE"),
+			dryRun: z.boolean().default(false)
+		},
+		annotations: {
+			idempotentHint: true,
+			openWorldHint: true
+		}
+	}, async ({ projectId, localeId, content, format, keyPrefix, sourceFile, autoApprove, conflict, dryRun }) => {
+		if (DOCUMENT_FORMATS.has(format) && !sourceFile?.trim()) return errorResult(`${format} needs a sourceFile — a translated document is aligned to its source by position.`);
+		return jsonResult((await gql.request(IMPORT_TRANSLATIONS, {
+			projectId,
+			localeId,
+			input: {
+				content,
+				format,
+				keyPrefix,
+				sourceFile,
+				autoApprove,
+				conflict,
+				dryRun
+			}
+		})).importTranslations);
+	});
+}
+//#endregion
+//#region src/tools/index.ts
+/** Tool sets by product area — the unit of `toolSets` (Crowdin's `crowdin-tool-sets`). */
+const TOOL_SETS = {
+	ota: registerOtaTools,
+	config: registerConfigTools,
+	projects: registerProjectTools,
+	locales: registerLocaleTools,
+	keys: registerKeyTools,
+	translations: registerTranslationTools,
+	qa: registerQaTools,
+	glossary: registerGlossaryTools,
+	styleguides: registerStyleGuideTools,
+	tm: registerTmTools,
+	git: registerGitTools,
+	providers: registerProviderTools,
+	jobs: registerJobTools,
+	analytics: registerAnalyticsTools
+};
+/** The valid tool-set names clients may request. */
+const TOOL_SET_NAMES = Object.keys(TOOL_SETS);
+/** Resolves which tool sets to load. Empty / undefined / ['all'] → every set. */
+function selectSets(requested) {
+	if (!requested || requested.length === 0 || requested.includes("all")) return TOOL_SET_NAMES;
+	return TOOL_SET_NAMES.filter((name) => requested.includes(name));
+}
+/**
+* Registers the Syntholoc tool surface, honouring optional server-side filters:
+* tool-set (group) selection, read-only mode, and name-pattern filtering.
+*/
+function registerAllTools(server, gql, opts = {}) {
+	const target = applyToolFilter(server, opts);
+	for (const name of selectSets(opts.toolSets)) TOOL_SETS[name]?.(target, gql);
+}
+//#endregion
+//#region package.json
+var version = "0.6.1";
+//#endregion
+//#region src/build-server.ts
+/**
+* Builds a fully-configured Syntholoc MCP server (tools + resources + prompts)
+* bound to the given GraphQL client. Shared by the stdio entrypoint and the
+* NestJS remote `/mcp` (Streamable HTTP) endpoint.
+*
+* `opts` optionally narrows the exposed tool surface (tool sets, read-only mode,
+* name-pattern filter) so the agent sees only what a given client needs.
+*/
+function buildMcpServer(gql, opts = {}) {
+	const server = new McpServer({
+		name: "syntholoc",
+		version
+	});
+	registerAllTools(server, gql, opts);
+	registerResources(server, gql);
+	registerPrompts(server);
+	return server;
+}
+//#endregion
+export { TOOL_SET_NAMES as n, parseList as r, buildMcpServer as t };