engineering-memory 1.11.20 → 1.11.22

package/runtime/dist/src/mcp/onboarding-tools.js

@@ -2,6 +2,7 @@ import * as z from 'zod/v4';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { restrictedValueKind } from '../runtime/privacy-detector.js';
 import { languageTag } from '../runtime/questionnaire-store.js';
+import { copies, format, texts } from '../runtime/texts.js';
 import { answerChoice, answerData, askFailed, askQuestionnaire, resumeQuestionnaire, } from './questionnaire-tools.js';
 const uuid = z.string().uuid();
 const hash = z.string().regex(/^[a-f0-9]{64}$/);
@@ -18,58 +19,6 @@ const json = z.lazy(() => z.union([
     z.record(z.string(), json),
 ]));
 const object = z.record(z.string(), json);
-const inspectionCopy = {
-    tr: {
-        modes: {
-            refresh: 'Projenin hafızasını güncel kodla karşılaştırıp incelemeyi başlatalım mı?',
-            adopt: 'Mevcut projeyi mimarisiyle birlikte öğrenmeye başlayalım mı?',
-            rework: 'Rework planından önce mevcut projeyi incelemeye başlayalım mı?',
-        },
-        source: 'Kaynak',
-        scope: 'Mimari, state yönetimi, servisler, network katmanı, veri modelleri, ekranlar ve akışlar incelenecek.',
-        localChanges: 'Uygulama kodu değiştirilmeyecek. Commit edilmemiş değişiklikler ortak hafızaya alınmayacak.',
-        review: 'Bu onay incelemeyi başlatır. Kalıcı hafıza değişiklikleri ayrıca onayına sunulacak.',
-        rework: {
-            preserve: 'Rework hedefi: mevcut davranışı korumak.',
-            redesign: 'Rework hedefi: ürünü yeniden tasarlamak. Uygulama öncesinde hedef ayrıca onaylanacak.',
-        },
-        why: {
-            refresh: 'İnceleme, hafızadaki kayıtları bu kaynaktaki kodla karşılaştırır ve neyin değiştiğini çıkarır.',
-            adopt: 'Proje ilk kez hafızaya alınıyor. İnceleme, bu kaynaktaki kodu okuyup projenin nasıl çalıştığını çıkarır.',
-            rework: 'Yeniden yazım planının yazılabilmesi için önce projenin bugünkü hâli okunmalı.',
-        },
-        example: 'İnceleme bitince her ekran, servis ve akış için birer hafıza kaydı önerilir; hangilerinin yayınlanacağına sen karar verirsin.',
-        start: 'İncelemeyi başlat',
-        startDetail: 'İnceleme şimdi başlar. Kod değişmez; çıkan kayıtlar sonunda tek tek onayına gelir.',
-        defer: 'Şimdilik başlatma',
-        deferDetail: 'İnceleme başlamaz, hiçbir şey yazılmaz. Cevabın kaydedilir; bu kaynağı sonra incelemek yeni bir istek olur.',
-    },
-    en: {
-        modes: {
-            refresh: 'Start comparing project memory with the current code?',
-            adopt: 'Start learning the existing project and its architecture?',
-            rework: 'Start inspecting the existing project before planning its rework?',
-        },
-        source: 'Source',
-        scope: 'Inspect architecture, state, services, network, data models, screens and flows.',
-        localChanges: 'Application code will stay unchanged. Uncommitted changes will not enter shared memory.',
-        review: 'This approval starts the inspection. Permanent memory changes will be submitted for separate approval.',
-        rework: {
-            preserve: 'Rework goal: preserve existing behavior.',
-            redesign: 'Rework goal: redesign the product. The target needs separate approval before implementation.',
-        },
-        why: {
-            refresh: 'The inspection compares the records already in memory with the code at that source and works out what changed.',
-            adopt: 'The project enters memory for the first time. The inspection reads the code at that source and works out how the project behaves.',
-            rework: 'The rework plan can only be written once the project as it stands today is read.',
-        },
-        example: 'When the inspection finishes, a memory record is proposed for each screen, service and flow, and you decide which of them get published.',
-        start: 'Start inspection',
-        startDetail: 'The inspection starts now. The code stays unchanged and every record it writes comes back for your approval.',
-        defer: 'Not now',
-        deferDetail: 'Nothing is inspected and nothing is written. Your answer is recorded, so inspecting this source later is a new request.',
-    },
-};
 const reference = z.object({
     proposalId: uuid,
     contentHash: hash,
@@ -94,82 +43,47 @@ const kind = z.enum([
     'quality_gate',
     'architecture_template',
 ]);
-const batchCopy = {
-    en: {
-        one: 'One memory record is ready to be published.',
-        many: (count) => `${count} memory records are ready to be published.`,
-        context: 'Publishing replaces the current text of these records for everyone who reads this memory. Earlier revisions stay in the history.',
-        unversioned: (titles) => ` Written without a source inspection: ${titles}. Tasks that read memory by source version will not see them until an inspection retains them.`,
-        example: 'After publishing, the next session that reads one of these records gets the new text instead of the old one.',
-        untitled: 'untitled',
-        scope: { project: 'project', organization: 'organization', product: 'product' },
-        newRecord: 'new record',
-        revision: (from) => `revision ${from} to ${from + 1}`,
-        rebase: 'written against an older revision',
-        why: 'Why',
-        approved: ['Publish all of them', 'Every listed record takes its new text now.'],
-        rejected: [
-            'Reject all of them',
-            'Nothing changes. The proposals are marked rejected and have to be written again.',
-        ],
-        oneByOne: [
-            'Let me look at them one by one',
-            'Nothing changes now. Each record is shown in full and decided on its own.',
-        ],
-        defer: ['Decide later', 'Nothing changes. The proposals stay pending.'],
-    },
-    tr: {
-        one: 'Bir hafıza kaydı yayına hazır.',
-        many: (count) => `${count} hafıza kaydı yayına hazır.`,
-        context: 'Yayınlarsan bu kayıtların mevcut metni, bu hafızayı okuyan herkes için değişir. Eski sürümler geçmişte kalır.',
-        unversioned: (titles) => ` Kaynak incelemesi yapılmadan yazılanlar: ${titles}. Hafızayı kaynak sürümüne göre okuyan görevler, bir inceleme bunları saklayana kadar görmez.`,
-        example: 'Yayınladıktan sonra bu kayıtlardan birini okuyan bir sonraki oturum eski metni değil yenisini görür.',
-        untitled: 'başlıksız',
-        scope: { project: 'proje', organization: 'organizasyon', product: 'ürün' },
-        newRecord: 'yeni kayıt',
-        revision: (from) => `sürüm ${from} → ${from + 1}`,
-        rebase: 'eski bir sürüme göre yazılmış',
-        why: 'Nedeni',
-        approved: ['Hepsini yayınla', 'Listedeki her kayıt şimdi yeni metnine geçer.'],
-        rejected: [
-            'Hepsini reddet',
-            'Hiçbir şey değişmez. Öneriler reddedilir ve yeniden yazılmaları gerekir.',
-        ],
-        oneByOne: [
-            'Tek tek bakayım',
-            'Şimdi hiçbir şey değişmez. Her kayıt tam metniyle gösterilir ve ayrı ayrı karara bağlanır.',
-        ],
-        defer: ['Şimdilik karar verme', 'Hiçbir şey değişmez. Öneriler beklemede kalır.'],
-    },
-};
-const kindInTurkish = {
-    engineering_rule: 'mühendislik kuralı',
-    project_profile: 'proje profili',
-    service_contract: 'servis sözleşmesi',
-    localization_contract: 'yerelleştirme sözleşmesi',
-    navigation_contract: 'gezinme sözleşmesi',
-    state_contract: 'durum yönetimi sözleşmesi',
-    screen_logic: 'ekran mantığı',
-    flow_logic: 'akış mantığı',
-    module_logic: 'modül mantığı',
-    data_model: 'veri modeli',
-    api_endpoint: 'API endpoint kaydı',
-    component_mapping: 'bileşen eşlemesi',
-    figma_mapping: 'Figma eşlemesi',
-    figma_reference: 'Figma referansı',
-    current_deviation: 'kayıtlı sapma',
-    quality_gate: 'kalite kapısı',
-    architecture_template: 'mimari şablonu',
-};
-function batchQuestion(turkish, proposals) {
-    const copy = batchCopy[turkish ? 'tr' : 'en'];
+const text = z.string().min(1);
+const option = z.strictObject({ label: text, description: text });
+const inspectionWording = z.strictObject({
+    modes: z.strictObject({ refresh: text, adopt: text, rework: text }),
+    source: text,
+    scope: text,
+    localChanges: text,
+    review: text,
+    rework: z.strictObject({ preserve: text, redesign: text }),
+    why: z.strictObject({ refresh: text, adopt: text, rework: text }),
+    example: text,
+    start: text,
+    startDetail: text,
+    defer: text,
+    deferDetail: text,
+});
+const reviewWording = z.strictObject({
+    ready: text,
+    context: text,
+    unversioned: text,
+    example: text,
+    untitled: text,
+    scope: z.strictObject({ project: text, organization: text, product: text }),
+    newRecord: text,
+    revision: text,
+    rebase: text,
+    why: text,
+    approved: option,
+    rejected: option,
+    oneByOne: option,
+    defer: option,
+    kinds: z.record(kind, text),
+});
+function batchQuestion(copy, language, proposals) {
     const clean = (text) => (restrictedValueKind(text, 'message', true) ? undefined : text);
     const named = proposals.map((proposal) => {
-        const kind = (turkish && kindInTurkish[proposal.kind]) || proposal.kind.replaceAll('_', ' ');
+        const kind = copy.kinds[proposal.kind] ?? proposal.kind.replaceAll('_', ' ');
         return {
             proposal,
             kind,
-            title: clean(proposal.title.slice(0, 70)) ?? `${copy.untitled} ${kind}`,
+            title: clean(proposal.title.slice(0, 70)) ?? format(copy.untitled, language, { kind }),
         };
     });
     const unversioned = named
@@ -178,21 +92,22 @@ function batchQuestion(turkish, proposals) {
         .join(', ');
     return {
         message: [
-            proposals.length === 1 ? copy.one : copy.many(proposals.length),
+            format(copy.ready, language, { count: proposals.length }),
             ...named.map(({ proposal, kind, title }, index) => {
-                const line = `${index + 1}. ${title} (${kind}, ${copy.scope[proposal.scope]}, ${proposal.currentRevisionNumber === 0
-                    ? copy.newRecord
-                    : copy.revision(proposal.currentRevisionNumber)}${proposal.rebaseRequired ? `, ${copy.rebase}` : ''})`;
+                const from = proposal.currentRevisionNumber;
+                const line = `${index + 1}. ${title} (${kind}, ${copy.scope[proposal.scope]}, ${from === 0 ? copy.newRecord : format(copy.revision, language, { from, to: from + 1 })}${proposal.rebaseRequired ? `, ${copy.rebase}` : ''})`;
                 return clean(`${line} ${copy.why}: ${proposal.reasonPreview.slice(0, 60)}`) ?? line;
             }),
         ].join('\n'),
-        context: copy.context + (unversioned ? copy.unversioned(unversioned) : ''),
+        context: unversioned
+            ? `${copy.context} ${format(copy.unversioned, language, { titles: unversioned })}`
+            : copy.context,
         example: copy.example,
         options: [
-            { id: 'approved', label: copy.approved[0], description: copy.approved[1] },
-            { id: 'rejected', label: copy.rejected[0], description: copy.rejected[1] },
-            { id: 'one_by_one', label: copy.oneByOne[0], description: copy.oneByOne[1] },
-            { id: 'defer', label: copy.defer[0], description: copy.defer[1] },
+            { id: 'approved', label: copy.approved.label, description: copy.approved.description },
+            { id: 'rejected', label: copy.rejected.label, description: copy.rejected.description },
+            { id: 'one_by_one', label: copy.oneByOne.label, description: copy.oneByOne.description },
+            { id: 'defer', label: copy.defer.label, description: copy.defer.description },
         ],
     };
 }
@@ -254,78 +169,27 @@ const onboardingInput = z.strictObject({
     language: languageTag.optional(),
     reworkBehavior: z.enum(['preserve', 'redesign']).optional(),
 });
-const moveCopy = {
-    tr: {
-        ask: (name) => `"${name}" projesini bu depoya taşıyalım mı?`,
-        from: 'Projenin şu anki deposu',
-        to: 'Bu klasörün deposu',
-        unknown: 'adresi kayıtlı değil',
-        keeps: (tasks, records, items) => `Proje olduğu gibi devam eder: ${tasks} görev, ${records} hafıza kaydı ve ${items} iş kalemi projede kalır, hiçbir şey silinmez ve yeniden öğrenilmez.`,
-        after: 'Eski depo projenin geçmişinde saklanır. Hâlâ eski depoda çalışan ekip arkadaşları açık görevlerini bitirebilir, yeni görevi yeni depodan açar. Proje ileride yeniden taşınabilir.',
-        why: 'Projenin kodu başka bir depoya taşınmış. Bu klasör projenin evi sayılmadığı için burada yeni iş başlatılamıyor.',
-        example: 'Taşıdıktan sonra bu klasörde açtığın görev aynı projeye ait olur ve aynı hafızayı okur.',
-        approve: [
-            'Projeyi bu depoya taşı',
-            'Proje bundan sonra bu depoyu gösterir; burada hemen çalışmaya başlayabilirsin.',
-        ],
-        decline: [
-            'Taşıma',
-            'Hiçbir şey değişmez. Proje mevcut deposunda kalır ve bu klasörde iş başlatılamaz.',
-        ],
-    },
-    en: {
-        ask: (name) => `Move the project "${name}" to this repository?`,
-        from: 'The project lives in',
-        to: 'This folder points at',
-        unknown: 'address not recorded',
-        keeps: (tasks, records, items) => `The project continues as it is: ${tasks} tasks, ${records} memory records and ${items} work items stay with it; nothing is deleted or learned again.`,
-        after: 'The old repository is kept in the project history. Teammates still working in it can finish their open tasks and start new ones from the new repository. The project can be moved again later.',
-        why: 'The code of this project moved to another repository. This folder is not recognised as the home of the project, so no new work can start here.',
-        example: 'After the move, a task started in this folder belongs to the same project and reads the same memory as before.',
-        approve: [
-            'Move the project here',
-            'The project points at this repository from now on and work can start here right away.',
-        ],
-        decline: [
-            'Do not move',
-            'Nothing changes. The project keeps its current repository and no work can start in this folder.',
-        ],
-    },
-};
-const planCopy = {
-    tr: {
-        one: 'Bu yeniden yazım planındaki tek aşama için iş kalemi oluşturalım mı?',
-        many: (count) => `Bu yeniden yazım planındaki ${count} aşama için iş kalemleri oluşturalım mı?`,
-        branch: 'dal',
-        more: (count) => `ve ${count} aşama daha`,
-        context: 'Onaylarsan plandaki her aşama için bağımlılık sırasına göre birer iş kalemi oluşturulur; başka hiçbir şey olmaz. Dal açılmaz, koda dokunulmaz. Her aşama daha sonra kendi görevi, kendi dalı ve kendi worktree ile ayrı ayrı yapılır.',
-        example: 'Onaydan sonra ilk aşama başlatılabilir bir iş kalemi olarak görünür; ona bağlı aşamalar o bitene kadar bekler.',
-        approve: [
-            'Bu iş kalemlerini oluştur',
-            'İş kalemleri listelendiği gibi şimdi oluşturulur. Aşamaların kodlanması yine ayrı ayrı başlar.',
-        ],
-        defer: [
-            'Plan beklemede kalsın',
-            'Hiçbir şey değişmez. İş kalemi oluşturulmaz, planı sonra onaylayabilirsin.',
-        ],
-    },
-    en: {
-        one: 'Create the work item for the single phase of this rework plan?',
-        many: (count) => `Create the work items for the ${count} phases of this rework plan?`,
-        branch: 'branch',
-        more: (count) => `and ${count} more phases`,
-        context: 'Approving creates one work item per phase, in the dependency order of the plan, and nothing else. No branch is created and no code is changed. Each phase is implemented later as its own task, with its own branch and worktree.',
-        example: 'After approval the first phase appears as a work item that can be started, and the phases that depend on it wait until it is done.',
-        approve: [
-            'Create these work items',
-            'The work items are created now, exactly as listed. Implementing each phase still starts separately.',
-        ],
-        defer: [
-            'Keep the plan for further review',
-            'Nothing changes. No work item is created and the plan can be approved later.',
-        ],
-    },
-};
+const moveWording = z.strictObject({
+    ask: text,
+    from: text,
+    to: text,
+    unknown: text,
+    keeps: text,
+    after: text,
+    why: text,
+    example: text,
+    approve: option,
+    decline: option,
+});
+const reworkWording = z.strictObject({
+    phases: text,
+    branch: text,
+    more: text,
+    context: text,
+    example: text,
+    approve: option,
+    defer: option,
+});
 export function registerOnboardingTools(server, service) {
     server.registerTool('project.move_repository', {
         description: 'Move an existing project to the repository this checkout points at, after its code moved (another host, a new remote, a history restart). Project owners only. Opens ONE durable native form naming the old and the new repository; on approval the project keeps every task, memory record, work item and open session, the old repository is kept in its history, and this checkout is bound. Use it when project.resolve with bind refuses with recovery project.move_repository; never create a second project for moved code. Pass language as the BCP-47 tag of the language the user writes in; it is remembered. Reconsider a declined move with a new decisionAttempt; retries keep the same attempt.',
@@ -337,7 +201,7 @@ export function registerOnboardingTools(server, service) {
             presentation: z.enum(['host_native']).optional(),
         }),
     }, async (input, context) => {
-        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
+        const wording = copies(moveWording, 'move', await service.language(input.language));
         const preflight = await service.projectRepositoryMovePreflight(input);
         if (!preflight.ok)
             return output(preflight);
@@ -371,46 +235,41 @@ export function registerOnboardingTools(server, service) {
                 version: flight.history.lockVersion,
                 ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
             }));
-        const definitions = ['tr', 'en'].map((displayLanguage) => {
-            const copy = moveCopy[displayLanguage];
-            return {
-                questionnaireId,
-                language: displayLanguage,
-                message: [
-                    copy.ask(name),
-                    `${copy.from}: ${from ?? copy.unknown}`,
-                    `${copy.to}: ${to ?? copy.unknown}`,
-                ].join('\n'),
-                context: [
-                    copy.why,
-                    copy.keeps(records.tasks, records.memoryRecords, records.workItems),
-                    copy.after,
-                ].join(' '),
-                example: copy.example,
-                options: [
-                    { id: 'approve', label: copy.approve[0], description: copy.approve[1] },
-                    { id: 'decline', label: copy.decline[0], description: copy.decline[1] },
-                ],
-            };
-        });
-        const previousWording = ['tr', 'en'].map((displayLanguage) => {
-            const copy = moveCopy[displayLanguage];
-            return {
-                questionnaireId,
-                language: displayLanguage,
-                message: [
-                    copy.ask(name),
-                    `${copy.from}: ${from ?? copy.unknown}`,
-                    `${copy.to}: ${to ?? copy.unknown}`,
-                    copy.keeps(records.tasks, records.memoryRecords, records.workItems),
-                    copy.after,
-                ].join('\n'),
-                options: [
-                    { id: 'approve', label: copy.approve[0] },
-                    { id: 'decline', label: copy.decline[0] },
-                ],
-            };
-        });
+        const counts = {
+            tasks: records.tasks,
+            records: records.memoryRecords,
+            items: records.workItems,
+        };
+        const definitions = wording.map(({ language, copy }) => ({
+            questionnaireId,
+            language,
+            message: [
+                format(copy.ask, language, { name }),
+                `${copy.from}: ${from ?? copy.unknown}`,
+                `${copy.to}: ${to ?? copy.unknown}`,
+            ].join('\n'),
+            context: [copy.why, format(copy.keeps, language, counts), copy.after].join(' '),
+            example: copy.example,
+            options: [
+                { id: 'approve', label: copy.approve.label, description: copy.approve.description },
+                { id: 'decline', label: copy.decline.label, description: copy.decline.description },
+            ],
+        }));
+        const previousWording = wording.map(({ language, copy }) => ({
+            questionnaireId,
+            language,
+            message: [
+                format(copy.ask, language, { name }),
+                `${copy.from}: ${from ?? copy.unknown}`,
+                `${copy.to}: ${to ?? copy.unknown}`,
+                format(copy.keeps, language, counts),
+                copy.after,
+            ].join('\n'),
+            options: [
+                { id: 'approve', label: copy.approve.label },
+                { id: 'decline', label: copy.decline.label },
+            ],
+        }));
         const binding = { decision: questionnaireId };
         const bound = definitions.map((entry) => ({ ...entry, binding }));
         const asked = {
@@ -422,7 +281,7 @@ export function registerOnboardingTools(server, service) {
         const form = stored?.binding && stableStringify(stored.binding) === stableStringify(binding)
             ? await resumeQuestionnaire(server, service, asked, context)
             : await askQuestionnaire(server, service, {
-                ...bound.find((entry) => entry.language === language),
+                ...bound[0],
                 repoRoot: input.repoRoot,
                 presentation: input.presentation,
             }, context, [...bound, ...definitions, ...previousWording], {
@@ -550,36 +409,33 @@ export function registerOnboardingTools(server, service) {
         }),
     }, async (input, context) => {
         const { repoRoot: root, language: told, ...plan } = input;
-        const language = (await service.language(told))?.startsWith('tr') ? 'tr' : 'en';
         const digest = sha256(stableStringify(plan));
         const questionnaireId = 'rework-' + digest;
         const shown = plan.phases.slice(0, 8);
-        const definitions = ['tr', 'en'].map((displayLanguage) => {
-            const copy = planCopy[displayLanguage];
-            return {
-                questionnaireId,
-                language: displayLanguage,
-                message: [
-                    plan.phases.length === 1 ? copy.one : copy.many(plan.phases.length),
-                    ...shown.map((phase, index) => {
-                        const branch = `${copy.branch}: ${phase.branch.slice(0, 60)}`;
-                        const line = `${index + 1}. ${phase.title.slice(0, 70)} (${branch})`;
-                        return restrictedValueKind(line, 'message', true) ? `${index + 1}. ${branch}` : line;
-                    }),
-                    ...(plan.phases.length > shown.length
-                        ? [copy.more(plan.phases.length - shown.length)]
-                        : []),
-                ].join('\n'),
-                context: copy.context,
-                example: copy.example,
-                options: [
-                    { id: 'approve', label: copy.approve[0], description: copy.approve[1] },
-                    { id: 'defer', label: copy.defer[0], description: copy.defer[1] },
-                ],
-                binding: { planDigest: digest },
-            };
-        });
-        const answer = await askQuestionnaire(server, service, { ...definitions.find((entry) => entry.language === language), repoRoot: root }, context, [
+        const wording = copies(reworkWording, 'reworkPlan', await service.language(told));
+        const definitions = wording.map(({ language, copy }) => ({
+            questionnaireId,
+            language,
+            message: [
+                format(copy.phases, language, { count: plan.phases.length }),
+                ...shown.map((phase, index) => {
+                    const branch = `${copy.branch}: ${phase.branch.slice(0, 60)}`;
+                    const line = `${index + 1}. ${phase.title.slice(0, 70)} (${branch})`;
+                    return restrictedValueKind(line, 'message', true) ? `${index + 1}. ${branch}` : line;
+                }),
+                ...(plan.phases.length > shown.length
+                    ? [format(copy.more, language, { count: plan.phases.length - shown.length })]
+                    : []),
+            ].join('\n'),
+            context: copy.context,
+            example: copy.example,
+            options: [
+                { id: 'approve', label: copy.approve.label, description: copy.approve.description },
+                { id: 'defer', label: copy.defer.label, description: copy.defer.description },
+            ],
+            binding: { planDigest: digest },
+        }));
+        const answer = await askQuestionnaire(server, service, { ...definitions[0], repoRoot: root }, context, [
             ...definitions,
             {
                 questionnaireId,
@@ -644,52 +500,45 @@ export function registerOnboardingTools(server, service) {
                 },
             });
         const { language: told, ...request } = input;
-        const language = (await service.language(told))?.startsWith('tr') ? 'tr' : 'en';
+        const wording = copies(inspectionWording, 'inspection', await service.language(told));
         const pinned = { ...request, ref: commit };
         const digest = sha256(stableStringify(pinned));
         const reference = input.ref ?? 'HEAD';
         const sourceLabel = /^[0-9a-f]{40,64}$/i.test(reference)
             ? commit.slice(0, 12)
             : `${reference.slice(0, 80)} · ${commit.slice(0, 12)}`;
-        const definitions = ['tr', 'en'].map((displayLanguage) => {
-            const copy = inspectionCopy[displayLanguage];
-            return {
-                questionnaireId: 'sync-start-' + digest,
-                language: displayLanguage,
-                message: [
-                    copy.modes[input.mode],
-                    `${copy.source}: ${sourceLabel}`,
-                    ...(input.reworkBehavior ? [copy.rework[input.reworkBehavior]] : []),
-                ].join('\n\n'),
-                context: [copy.why[input.mode], copy.scope, copy.localChanges, copy.review].join(' '),
-                example: copy.example,
-                options: [
-                    { id: 'approve', label: copy.start, description: copy.startDetail },
-                    { id: 'defer', label: copy.defer, description: copy.deferDetail },
-                ],
-            };
-        });
-        const previousWording = ['tr', 'en'].map((displayLanguage) => {
-            const copy = inspectionCopy[displayLanguage];
-            return {
-                questionnaireId: 'sync-start-' + digest,
-                language: displayLanguage,
-                message: [
-                    copy.modes[input.mode],
-                    `${copy.source}: ${sourceLabel}`,
-                    copy.scope,
-                    copy.localChanges,
-                    copy.review,
-                    ...(input.reworkBehavior ? [copy.rework[input.reworkBehavior]] : []),
-                ].join('\n\n'),
-                options: [
-                    { id: 'approve', label: copy.start },
-                    { id: 'defer', label: copy.defer },
-                ],
-            };
-        });
-        const definition = definitions.find((entry) => entry.language === language);
-        const question = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot }, context, [
+        const definitions = wording.map(({ language, copy }) => ({
+            questionnaireId: 'sync-start-' + digest,
+            language,
+            message: [
+                copy.modes[input.mode],
+                `${copy.source}: ${sourceLabel}`,
+                ...(input.reworkBehavior ? [copy.rework[input.reworkBehavior]] : []),
+            ].join('\n\n'),
+            context: [copy.why[input.mode], copy.scope, copy.localChanges, copy.review].join(' '),
+            example: copy.example,
+            options: [
+                { id: 'approve', label: copy.start, description: copy.startDetail },
+                { id: 'defer', label: copy.defer, description: copy.deferDetail },
+            ],
+        }));
+        const previousWording = wording.map(({ language, copy }) => ({
+            questionnaireId: 'sync-start-' + digest,
+            language,
+            message: [
+                copy.modes[input.mode],
+                `${copy.source}: ${sourceLabel}`,
+                copy.scope,
+                copy.localChanges,
+                copy.review,
+                ...(input.reworkBehavior ? [copy.rework[input.reworkBehavior]] : []),
+            ].join('\n\n'),
+            options: [
+                { id: 'approve', label: copy.start },
+                { id: 'defer', label: copy.defer },
+            ],
+        }));
+        const question = await askQuestionnaire(server, service, { ...definitions[0], repoRoot: input.repoRoot }, context, [
             ...definitions,
             ...previousWording,
             {
@@ -875,7 +724,7 @@ export function registerOnboardingTools(server, service) {
             questionnaireId: 'memory-review-' + digest + '-' + input.reviewAttempt,
         };
         const binding = body({ projectId: input.projectId, entries });
-        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
+        const { language, copy } = copies(reviewWording, 'reviewBatch', await service.language(input.language))[0];
         const stored = await service.questionnaireResume(question).catch(() => undefined);
         let result;
         if (stored && stableStringify(stored.binding) === stableStringify(binding))
@@ -908,7 +757,7 @@ export function registerOnboardingTools(server, service) {
                         recovery: 'memory.list_proposals',
                     },
                 });
-            result = await askQuestionnaire(server, service, { ...question, language, ...batchQuestion(language === 'tr', proposals), binding }, context);
+            result = await askQuestionnaire(server, service, { ...question, language, ...batchQuestion(copy, language, proposals), binding }, context);
         }
         const decision = answerChoice(result);
         if (decision === 'defer' || decision === 'one_by_one')
@@ -934,285 +783,110 @@ export function registerOnboardingTools(server, service) {
         })));
     });
 }
-const profileFieldNames = {
-    tr: {
-        stack: 'Uygulama teknolojisi',
-        runtime: 'Çalışma ortamı ve araç sürümleri',
-        architecture: 'Uygulama mimarisi',
-        environments: 'Ortamlar ve konfigürasyon',
-        serviceReadiness: 'Servislerin hazır olup olmadığı',
-        apiContract: 'API sözleşmesi',
-        authentication: 'Kimlik doğrulama',
-        storage: 'Veri saklama',
-        backendProjectIds: 'Bağlı backend projeleri',
-        migrations: 'Migration stratejisi',
-        figma: 'Figma kaynağı',
-        colorPalette: 'Renk paleti',
-        typography: 'Yazı tipleri ve metin stilleri',
-        designSystem: 'Tasarım sistemi',
-        navigation: 'Gezinme',
-        platforms: 'Platformlar',
-        localization: 'Desteklenen diller',
-    },
-    en: {
-        stack: 'Application stack',
-        runtime: 'Runtime and toolchain contract',
-        architecture: 'Application architecture',
-        environments: 'Environments and configuration',
-        serviceReadiness: 'Service readiness',
-        apiContract: 'API contract',
-        authentication: 'Authentication',
-        storage: 'Storage and persistence',
-        backendProjectIds: 'Existing backend project links',
-        migrations: 'Migration strategy',
-        figma: 'Figma source',
-        colorPalette: 'Color palette',
-        typography: 'Font families and text styles',
-        designSystem: 'Design system',
-        navigation: 'Navigation',
-        platforms: 'Platforms',
-        localization: 'Localization languages',
-    },
-};
-const onboardingCopy = {
-    tr: {
-        mode: {
-            message: 'Bu proje Engineering Memory hafızasına nasıl alınsın?',
-            context: 'Cevabın ilk adımı belirler: proje sıfırdan mı kurulacak, mevcut proje olduğu gibi okunup korunacak mı, yoksa önce okunup sonra aşama aşama mı yeniden yazılacak. Mevcut bir projeyi okumak ne kodu ne de mimarisini değiştirir.',
-            example: 'Mevcut projeyi öğrenmeyi seçersen bir sonraki adım kodu okuyup nasıl çalıştığını kayda geçirir; tek satır bile değişmez.',
-            greenfield: [
-                'Yeni ya da yeni başlamış bir proje kur',
-                'Proje birazdan onaylayacağın profille başlar; mevcut kod okunmaz.',
-            ],
-            adopt: [
-                'Mevcut mimariyi öğren ve koru',
-                'Kod olduğu gibi okunup hafızaya yazılır; hiçbir şey yeniden tasarlanmaz.',
-            ],
-            rework: [
-                'Önce öğren, sonra aşama aşama yeniden yazmayı planla',
-                'Önce kod okunur; yeniden yazım planı ayrıca onaylanmadan hiçbir şey değişmez.',
-            ],
-            refresh: [
-                'Hafızayı güncel projeyle tazele',
-                'Hafızadaki kayıtlar güncel kodla karşılaştırılır, farklar öneri olarak önüne gelir.',
-            ],
-        },
-        behavior: {
-            message: 'Yeniden yazım, ürünün bugünkü davranışını koruyacak mı yoksa ürünü yeniden mi tasarlayacak?',
-            context: 'Bu seçim hem incelemenin hem de planın hedefini belirler. Korumak, kullanıcının gördüğü ekranlar ve akışlar aynı kalırken altındaki kodun değişmesi demek. Yeniden tasarlamak ürünün kendisinin değişmesi demek; o zaman hedef ekranlar, akışlar ve sözleşmeler uygulamaya geçilmeden önce ayrıca onaylanır.',
-            example: 'Davranışı korursan, bugün seri numarası soran ekran yeniden yazımdan sonra da seri numarası sorar.',
-            preserve: [
-                'Bugünkü davranışı koru',
-                'Yeniden yazım yalnızca kodun yapısını değiştirir; kullanıcının gördüğü aynı kalır.',
-            ],
-            redesign: [
-                'Ürünü açıkça yeniden tasarla',
-                'Hedef ekranlar, akışlar ve sözleşmeler onaylanmadan hiçbir şey uygulanmaz.',
-            ],
-        },
-        field: {
-            value: 'Önerilen değer',
-            empty: 'henüz belirlenmedi',
-            context: 'Bu değer kurulum seçimleriyle birlikte kaydedilir; sonraki görevler tahmin etmek yerine buradan okur. Olduğu gibi bırakabilir, farklı bir değer yazabilir ya da şimdilik boş bırakabilirsin; boş bıraktığın bir değer sessizce kaydedilmez.',
-            example: 'Çalışma ortamı Node 22 olarak kalırsa sonraki görev makinede ne varsa ona göre değil, Node 22 üzerinde derleyip test eder.',
-            keep: ['Bu değeri olduğu gibi kaydet', 'Yukarıdaki değer aynen kaydedilir.'],
-            change: (value) => `${value} olarak değiştir`,
-            changeDetail: (value) => `Proje ${value} olarak kaydedilir ve kalan sorular buna göre gelir.`,
-            edit: [
-                'Aşağıdaki alana farklı bir değer yaz',
-                'Aşağıya yazdığın metin, yukarıdaki değerin yerine kaydedilir.',
-            ],
-            defer: [
-                'Bu değeri şimdilik boş bırak',
-                'Hiçbir şey kaydedilmez. Kurulum burada durur; karar verdiğinde bu soruya dönersin.',
-            ],
-            editTitle: 'Yeni değer',
-            idsTitle: 'Proje ID listesi (JSON dizisi)',
-        },
-        git: {
-            development: {
-                message: 'Yeni görev dalları hangi daldan başlasın?',
-                context: 'Bundan sonra açtığın her görev bu daldan dallanır ve bu dalla karşılaştırılır. Henüz var olmayan bir depo için ilk dalın alacağı ismi yaz. Dal, depo origin adresine bağlandıktan sonra orada kullanılır.',
-                example: 'Buraya main yazarsan sonraki görev main üzerinden dallanır ve pull request main dalına açılır.',
-                second: [
-                    'Şimdilik kuruluma başlama',
-                    'Hiçbir şey kaydedilmez, kurulum burada durur; istediğinde devam edebilirsin.',
-                ],
-            },
-            production: {
-                message: 'Bu projenin canlı sürümü hangi daldan çıkıyor?',
-                context: 'Bir kez kaydedilir; sonraki işler biten bir değişikliğin nereye gideceğini buradan bilir. Böyle bir dal henüz yoksa bunu açıkça söyle, bir daha sorulmaz.',
-                example: 'Canlı dal main ise, biten bir görevin nereye gideceği sana tekrar sorulmaz.',
-                second: [
-                    'Henüz canlı dal yok',
-                    'Yok olarak kaydedilir ve bir daha sorulmaz. İleride belirleyebilirsin.',
-                ],
-            },
-            test: {
-                message: 'Bu proje hangi dalda test ediliyor?',
-                context: 'Bir kez kaydedilir; sonraki işler biten bir değişikliğin nerede test edileceğini buradan bilir. Böyle bir dal henüz yoksa bunu açıkça söyle, bir daha sorulmaz.',
-                example: 'Test dalı develop ise, testlerin hangi dalda koştuğu sana tekrar sorulmaz.',
-                second: [
-                    'Henüz test dalı yok',
-                    'Yok olarak kaydedilir ve bir daha sorulmaz. İleride belirleyebilirsin.',
-                ],
-            },
-            set: ['Aşağıya yazdığım dalı kullan', 'Yazdığın dal bu proje için kaydedilir.'],
-            branchTitle: 'Dal adı',
-        },
-        save: {
-            message: 'Bu kurulum seçimlerini kaydedelim mi?',
-            routeLabel: 'Seçilen yol',
-            route: {
-                greenfield: 'yeni bir proje kur',
-                adopt: 'mevcut projeyi öğren ve koru',
-                rework: 'önce öğren, sonra aşama aşama yeniden yazmayı planla',
-                refresh: 'hafızayı güncel projeyle tazele',
-            },
-            context: 'Verdiğin cevaplar bu projenin kurulum kaydı olur; sonraki işler teknolojiyi, mimariyi ve kalan seçimleri oradan okur. Hafıza kayıtları ve proje bağlantıları ayrıca onaylanır, burada hafızaya hiçbir şey yayınlanmaz.',
-            git: ' Bu klasörde Git hazırlanır; mevcut dosyalar olduğu gibi kalır, hiçbiri silinmez veya değiştirilmez.',
-            example: 'Kaydettikten sonra sonraki görev teknolojiyi ve mimariyi sana tekrar sormadan buradan okur.',
-            approve: ['Bu seçimleri kaydet', 'Seçimler kaydedilir. Kodda hiçbir şey değişmez.'],
-            approveGit: 'Seçimler kaydedilir ve bu klasörde Git hazırlanır.',
-            defer: [
-                'Seçimleri beklemede bırak',
-                'Hiçbir şey kaydedilmez. Soruları sonra yeniden geçebilirsin.',
-            ],
-        },
-    },
-    en: {
-        mode: {
-            message: 'How should this project enter Engineering Memory?',
-            context: 'The answer decides what happens first: the project is set up from scratch, the existing one is read and preserved as it is, or it is read first and then reworked phase by phase. Reading an existing project never changes its code or its architecture.',
-            example: 'Choosing to learn the existing project means the next step reads the code and writes down how it works, without changing a line.',
-            greenfield: [
-                'Set up a new or barely-started project',
-                'The project starts from the profile you approve next; no existing code is read.',
-            ],
-            adopt: [
-                'Learn and preserve the existing architecture',
-                'The code is read as it stands and written into memory; nothing is redesigned.',
-            ],
-            rework: [
-                'Learn first, then plan a phased rework',
-                'The code is read first, and nothing changes until the rework plan is approved separately.',
-            ],
-            refresh: [
-                'Refresh memory against the current project',
-                'The records already in memory are compared with the current code and the differences come back as proposals.',
-            ],
-        },
-        behavior: {
-            message: 'Should the rework keep the product behaving as it does today, or redesign it?',
-            context: 'This decides what both the inspection and the plan aim at. Preserving means the screens and flows a user sees stay the same while the code underneath changes. Redesigning means the product itself changes, and the target screens, flows and contracts are approved before any implementation starts.',
-            example: 'If the behavior is preserved, a screen that asks for a serial number today still asks for it after the rework.',
-            preserve: [
-                'Preserve current behavior',
-                'The rework only changes how the code is built; what the user sees stays the same.',
-            ],
-            redesign: [
-                'Redesign the product explicitly',
-                'Nothing is implemented until the target screens, flows and contracts are approved.',
-            ],
-        },
-        field: {
-            value: 'Proposed value',
-            empty: 'not set yet',
-            context: 'This value is saved with the onboarding choices and later work reads it from there instead of guessing. Keep it, write a different one, or leave it undecided; a value left undecided is never saved quietly.',
-            example: 'If the runtime stays Node 22, a later task builds and tests on Node 22 instead of whatever the machine happens to have.',
-            keep: ['Keep this exact value', 'The value above is saved as it stands.'],
-            change: (value) => `Change to ${value}`,
-            changeDetail: (value) => `The project is saved as ${value} and the remaining questions follow it.`,
-            edit: [
-                'Edit this value in the field below',
-                'What you write below is saved instead of the value above.',
-            ],
-            defer: [
-                'Defer this value explicitly',
-                'Nothing is saved. Onboarding stops here and you come back to this question once you have decided.',
-            ],
-            editTitle: 'Edited value',
-            idsTitle: 'Project ID JSON array',
-        },
-        git: {
-            development: {
-                message: 'Which branch should new task branches start from?',
-                context: 'Every task you start later branches off this one and is compared against it. For a repository that does not exist yet, write the name its first branch will have. The branch is used on the origin remote once that remote is connected.',
-                example: 'With main here, a later task branches off main and its pull request targets main.',
-                second: [
-                    'Do not start setup yet',
-                    'Nothing is saved and setup stops here; you can continue whenever you want.',
-                ],
-            },
-            production: {
-                message: 'Which branch is this project released from?',
-                context: 'It is recorded once so later work knows where a finished change goes. If there is no such branch yet, say so explicitly and you are not asked again.',
-                example: 'With main as the release branch, where a finished task goes is never asked again.',
-                second: [
-                    'There is no release branch yet',
-                    'It is recorded as absent and you are not asked again. You can set it later.',
-                ],
-            },
-            test: {
-                message: 'Which branch is this project tested on?',
-                context: 'It is recorded once so later work knows where a finished change is tested. If there is no such branch yet, say so explicitly and you are not asked again.',
-                example: 'With develop as the test branch, where the tests run is never asked again.',
-                second: [
-                    'There is no test branch yet',
-                    'It is recorded as absent and you are not asked again. You can set it later.',
-                ],
-            },
-            set: ['Use the branch named below', 'That branch is saved for this project.'],
-            branchTitle: 'Branch name',
-        },
-        save: {
-            message: 'Save the onboarding choices you just went through?',
-            routeLabel: 'Chosen route',
-            route: {
-                greenfield: 'set up a new project',
-                adopt: 'learn and preserve the existing project',
-                rework: 'learn first, then plan a phased rework',
-                refresh: 'refresh memory against the current project',
-            },
-            context: 'Your answers become the onboarding record of this project, and later work reads the stack, the architecture and the remaining choices from there. Memory records and project links are approved separately; nothing is published to memory here.',
-            git: ' Git is prepared in this folder: existing files stay as they are and none of them is deleted or replaced.',
-            example: 'After saving, a later task reads the stack and the architecture from here instead of asking you again.',
-            approve: [
-                'Save these exact onboarding choices',
-                'The choices are saved. Nothing in the code changes.',
-            ],
-            approveGit: 'The choices are saved and Git is prepared in this folder.',
-            defer: [
-                'Keep the choices pending',
-                'Nothing is saved. You can go through the questions again later.',
-            ],
-        },
-    },
-};
+const profileField = z.enum([
+    'stack',
+    'runtime',
+    'architecture',
+    'environments',
+    'serviceReadiness',
+    'apiContract',
+    'authentication',
+    'storage',
+    'backendProjectIds',
+    'migrations',
+    'figma',
+    'colorPalette',
+    'typography',
+    'designSystem',
+    'navigation',
+    'platforms',
+    'localization',
+]);
+const branchQuestion = z.strictObject({
+    message: text,
+    context: text,
+    example: text,
+    second: option,
+});
+const onboardingWording = z.strictObject({
+    mode: z.strictObject({
+        message: text,
+        context: text,
+        example: text,
+        greenfield: option,
+        adopt: option,
+        rework: option,
+        refresh: option,
+    }),
+    behavior: z.strictObject({
+        message: text,
+        context: text,
+        example: text,
+        preserve: option,
+        redesign: option,
+    }),
+    field: z.strictObject({
+        value: text,
+        empty: text,
+        context: text,
+        example: text,
+        keep: option,
+        change: text,
+        changeDetail: text,
+        edit: option,
+        defer: option,
+        editTitle: text,
+        idsTitle: text,
+    }),
+    git: z.strictObject({
+        development: branchQuestion,
+        production: branchQuestion,
+        test: branchQuestion,
+        set: option,
+        branchTitle: text,
+    }),
+    save: z.strictObject({
+        message: text,
+        routeLabel: text,
+        route: z.record(onboardingMode, text),
+        context: text,
+        git: text,
+        example: text,
+        approve: option,
+        approveGit: text,
+        defer: option,
+    }),
+    fieldNames: z.record(profileField, text),
+});
 async function approveOnboarding(server, service, input, context, initialize) {
     const preparation = !input.projectId;
     const scope = { repoRoot: input.repoRoot, preparation };
-    const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
+    const wording = copies(onboardingWording, 'onboarding', await service.language(input.language));
+    const english = onboardingWording.parse(texts('onboarding', 'en'));
     const modeId = 'onboard-mode-' + sha256(input.requestKey);
-    const modeDefinitions = ['tr', 'en'].map((displayLanguage) => {
-        const copy = onboardingCopy[displayLanguage].mode;
+    const modeDefinitions = wording.map((entry) => {
+        const copy = entry.copy.mode;
         return {
             questionnaireId: modeId,
-            language: displayLanguage,
+            language: entry.language,
             message: copy.message,
             context: copy.context,
             example: copy.example,
             options: [
-                { id: 'greenfield', label: copy.greenfield[0], description: copy.greenfield[1] },
-                { id: 'adopt', label: copy.adopt[0], description: copy.adopt[1] },
-                { id: 'rework', label: copy.rework[0], description: copy.rework[1] },
+                {
+                    id: 'greenfield',
+                    label: copy.greenfield.label,
+                    description: copy.greenfield.description,
+                },
+                { id: 'adopt', label: copy.adopt.label, description: copy.adopt.description },
+                { id: 'rework', label: copy.rework.label, description: copy.rework.description },
                 ...(input.projectId
-                    ? [{ id: 'refresh', label: copy.refresh[0], description: copy.refresh[1] }]
+                    ? [{ id: 'refresh', label: copy.refresh.label, description: copy.refresh.description }]
                     : []),
             ],
         };
     });
-    const mode = await askQuestionnaire(server, service, { ...scope, ...modeDefinitions.find((entry) => entry.language === language) }, context, [
+    const mode = await askQuestionnaire(server, service, { ...scope, ...modeDefinitions[0] }, context, [
         ...modeDefinitions,
         {
             questionnaireId: modeId,
@@ -1240,21 +914,21 @@ async function approveOnboarding(server, service, input, context, initialize) {
         });
     if (selected === 'rework') {
         const behaviorId = 'rework-behavior-' + sha256(input.requestKey);
-        const behaviorDefinitions = ['tr', 'en'].map((displayLanguage) => {
-            const copy = onboardingCopy[displayLanguage].behavior;
+        const behaviorDefinitions = wording.map((entry) => {
+            const copy = entry.copy.behavior;
             return {
                 questionnaireId: behaviorId,
-                language: displayLanguage,
+                language: entry.language,
                 message: copy.message,
                 context: copy.context,
                 example: copy.example,
                 options: [
-                    { id: 'preserve', label: copy.preserve[0], description: copy.preserve[1] },
-                    { id: 'redesign', label: copy.redesign[0], description: copy.redesign[1] },
+                    { id: 'preserve', label: copy.preserve.label, description: copy.preserve.description },
+                    { id: 'redesign', label: copy.redesign.label, description: copy.redesign.description },
                 ],
             };
         });
-        const behavior = await askQuestionnaire(server, service, { ...scope, ...behaviorDefinitions.find((entry) => entry.language === language) }, context, [
+        const behavior = await askQuestionnaire(server, service, { ...scope, ...behaviorDefinitions[0] }, context, [
             ...behaviorDefinitions,
             {
                 questionnaireId: behaviorId,
@@ -1310,18 +984,15 @@ async function approveOnboarding(server, service, input, context, initialize) {
                 requiredForChoice: 'edit_value',
                 ...(field === 'backendProjectIds' ? { valueType: 'uuid_list' } : {}),
             };
-        const fieldDefinitions = ['tr', 'en'].map((displayLanguage) => {
-            const copy = onboardingCopy[displayLanguage].field;
+        const fieldDefinitions = wording.map((entry) => {
+            const copy = entry.copy.field;
             return {
                 questionnaireId: fieldId,
-                language: displayLanguage,
-                message: [
-                    profileFieldNames[displayLanguage][field],
-                    `${copy.value}: ${written || copy.empty}`,
-                ].join('\n'),
+                language: entry.language,
+                message: [entry.copy.fieldNames[field], `${copy.value}: ${written || copy.empty}`].join('\n'),
                 context: copy.context,
                 example: copy.example,
-                options: profileFieldOptions(field, currentValue, copy),
+                options: profileFieldOptions(field, currentValue, copy, entry.language),
                 ...(textField
                     ? {
                         textField: {
@@ -1332,13 +1003,13 @@ async function approveOnboarding(server, service, input, context, initialize) {
                     : {}),
             };
         });
-        const response = await askQuestionnaire(server, service, { ...scope, ...fieldDefinitions.find((entry) => entry.language === language) }, context, [
+        const response = await askQuestionnaire(server, service, { ...scope, ...fieldDefinitions[0] }, context, [
             ...fieldDefinitions,
             {
                 questionnaireId: fieldId,
                 message: 'Review this onboarding choice before it is persisted.\n' +
                     'Field: ' +
-                    profileFieldNames.en[field] +
+                    english.fieldNames[field] +
                     '\nCurrent value:\n' +
                     JSON.stringify(currentValue, null, 2) +
                     '\nKeep it, edit it in the bounded field below, or defer this field explicitly. A deferred field remains pending and is never silently saved as the current value.',
@@ -1378,27 +1049,27 @@ async function approveOnboarding(server, service, input, context, initialize) {
         gitPreferences = {};
         for (const role of ['development', 'production', 'test']) {
             const branchId = 'onboard-git-' + role + '-' + sha256(input.requestKey);
-            const branchDefinitions = ['tr', 'en'].map((displayLanguage) => {
-                const copy = onboardingCopy[displayLanguage].git;
+            const branchDefinitions = wording.map((entry) => {
+                const copy = entry.copy.git;
                 return {
                     questionnaireId: branchId,
-                    language: displayLanguage,
+                    language: entry.language,
                     message: copy[role].message,
                     context: copy[role].context,
                     example: copy[role].example,
                     options: [
-                        { id: 'set', label: copy.set[0], description: copy.set[1] },
+                        { id: 'set', label: copy.set.label, description: copy.set.description },
                         {
                             id: role === 'development' ? 'defer' : 'none',
-                            label: copy[role].second[0],
-                            description: copy[role].second[1],
+                            label: copy[role].second.label,
+                            description: copy[role].second.description,
                         },
                     ],
                     textField: { title: copy.branchTitle, maxLength: 255, requiredForChoice: 'set' },
                     allowFreeText: false,
                 };
             });
-            const response = await askQuestionnaire(server, service, { ...scope, ...branchDefinitions.find((entry) => entry.language === language) }, context, [
+            const response = await askQuestionnaire(server, service, { ...scope, ...branchDefinitions[0] }, context, [
                 ...branchDefinitions,
                 {
                     questionnaireId: branchId,
@@ -1438,26 +1109,26 @@ async function approveOnboarding(server, service, input, context, initialize) {
     };
     const digest = sha256(stableStringify(choice));
     const questionnaireId = 'onboard-profile-' + digest + (initialize ? '-initialize' : '-save');
-    const saveDefinitions = ['tr', 'en'].map((displayLanguage) => {
-        const copy = onboardingCopy[displayLanguage].save;
+    const saveDefinitions = wording.map((entry) => {
+        const copy = entry.copy.save;
         return {
             questionnaireId,
-            language: displayLanguage,
+            language: entry.language,
             message: [copy.message, `${copy.routeLabel}: ${copy.route[input.mode]}`].join('\n'),
-            context: copy.context + (initialize ? copy.git : ''),
+            context: initialize ? `${copy.context} ${copy.git}` : copy.context,
             example: copy.example,
             options: [
                 {
                     id: 'approve',
-                    label: copy.approve[0],
-                    description: initialize ? copy.approveGit : copy.approve[1],
+                    label: copy.approve.label,
+                    description: initialize ? copy.approveGit : copy.approve.description,
                 },
-                { id: 'defer', label: copy.defer[0], description: copy.defer[1] },
+                { id: 'defer', label: copy.defer.label, description: copy.defer.description },
             ],
             binding: { choiceDigest: digest },
         };
     });
-    const approval = await askQuestionnaire(server, service, { ...scope, ...saveDefinitions.find((entry) => entry.language === language) }, context, [
+    const approval = await askQuestionnaire(server, service, { ...scope, ...saveDefinitions[0] }, context, [
         ...saveDefinitions,
         {
             questionnaireId,
@@ -1519,26 +1190,26 @@ function parseEditedProfileValue(field, value) {
     return z.array(uuid).max(10).parse(parsed);
 }
 const stackValues = ['Flutter', 'React', 'Nest', 'Spring'];
-function profileFieldOptions(field, currentValue, copy) {
+function profileFieldOptions(field, currentValue, copy, language) {
     if (field === 'stack') {
         return [
-            { id: 'keep_current', label: copy.keep[0], description: copy.keep[1] },
+            { id: 'keep_current', label: copy.keep.label, description: copy.keep.description },
             ...stackValues
                 .filter((value) => value !== currentValue)
                 .map((value) => ({
                 id: value,
-                label: copy.change(value),
-                description: copy.changeDetail(value),
+                label: format(copy.change, language, { value }),
+                description: format(copy.changeDetail, language, { value }),
             })),
-            { id: 'defer_current', label: copy.defer[0], description: copy.defer[1] },
+            { id: 'defer_current', label: copy.defer.label, description: copy.defer.description },
         ];
     }
     return [
         ...(currentValue === null
             ? []
-            : [{ id: 'keep_current', label: copy.keep[0], description: copy.keep[1] }]),
-        { id: 'edit_value', label: copy.edit[0], description: copy.edit[1] },
-        { id: 'defer_current', label: copy.defer[0], description: copy.defer[1] },
+            : [{ id: 'keep_current', label: copy.keep.label, description: copy.keep.description }]),
+        { id: 'edit_value', label: copy.edit.label, description: copy.edit.description },
+        { id: 'defer_current', label: copy.defer.label, description: copy.defer.description },
     ];
 }
 function legacyProfileFieldOptions(field, currentValue) {