engineering-memory 1.11.10 → 1.11.12

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

@@ -1,6 +1,8 @@
 import * as z from 'zod/v4';
 import { sha256, stableStringify } from '../utilities/hash.js';
-import { answerChoice, answerData, askQuestionnaire } from './questionnaire-tools.js';
+import { restrictedValueKind } from '../runtime/privacy-detector.js';
+import { languageTag } from '../runtime/questionnaire-store.js';
+import { answerChoice, answerData, askQuestionnaire, resumeQuestionnaire, } from './questionnaire-tools.js';
 const uuid = z.string().uuid();
 const hash = z.string().regex(/^[a-f0-9]{64}$/);
 const project = { projectId: uuid };
@@ -31,8 +33,16 @@ const inspectionCopy = {
             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: {
@@ -48,8 +58,16 @@ const inspectionCopy = {
             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({
@@ -76,6 +94,108 @@ 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 clean = (text) => (restrictedValueKind(text, 'message', true) ? undefined : text);
+    const named = proposals.map((proposal) => {
+        const kind = (turkish && kindInTurkish[proposal.kind]) || proposal.kind.replaceAll('_', ' ');
+        return {
+            proposal,
+            kind,
+            title: clean(proposal.title.slice(0, 70)) ?? `${copy.untitled} ${kind}`,
+        };
+    });
+    const unversioned = named
+        .filter(({ proposal }) => proposal.sourceApplicabilityNotice)
+        .map(({ title }) => title)
+        .join(', ');
+    return {
+        message: [
+            proposals.length === 1 ? copy.one : copy.many(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}` : ''})`;
+                return clean(`${line} ${copy.why}: ${proposal.reasonPreview.slice(0, 60)}`) ?? line;
+            }),
+        ].join('\n'),
+        context: copy.context + (unversioned ? copy.unversioned(unversioned) : ''),
+        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] },
+        ],
+    };
+}
 const output = (result) => ({
     content: [{ type: 'text', text: JSON.stringify(result) }],
     ...(!result.ok ? { isError: true } : {}),
@@ -131,9 +251,201 @@ const onboardingInput = z.strictObject({
     mode: onboardingMode,
     profile,
     projectId: uuid.optional(),
+    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.',
+        ],
+    },
+};
 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.',
+        inputSchema: z.strictObject({
+            repoRoot,
+            projectId: uuid,
+            decisionAttempt: z.number().int().min(1).max(10000).optional(),
+            language: languageTag.optional(),
+            presentation: z.enum(['host_native']).optional(),
+        }),
+    }, async (input, context) => {
+        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
+        const preflight = await service.projectRepositoryMovePreflight(input);
+        if (!preflight.ok)
+            return output(preflight);
+        const flight = preflight.data;
+        if (flight.authentication)
+            return output(preflight);
+        if (flight.alreadyHere || !flight.history.current)
+            return output(await service.projectResolve({
+                repoRoot: input.repoRoot,
+                bind: true,
+                projectId: input.projectId,
+            }));
+        if (flight.history.role !== 'owner')
+            return output({
+                ok: false,
+                error: {
+                    kind: 'bridge_error',
+                    message: 'Only a project owner can move a project to another repository. List the members with project.member_list and ask an owner to run project.move_repository from a checkout of the new repository. Nothing was changed.',
+                    retryable: false,
+                    recovery: 'project.member_list',
+                },
+            });
+        const { name, records } = flight.history;
+        const from = flight.history.current.remoteIdentity;
+        const to = flight.checkout.remoteIdentity;
+        const questionnaireId = 'project-move-' +
+            sha256(stableStringify({
+                projectId: input.projectId,
+                from: flight.history.current.repoFingerprint,
+                to: flight.checkout.repoFingerprint,
+                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 form = await askQuestionnaire(server, service, {
+            ...definitions.find((entry) => entry.language === language),
+            repoRoot: input.repoRoot,
+            presentation: input.presentation,
+        }, context, [...definitions, ...previousWording], {
+            tool: 'project.move_repository',
+            ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+            retryArguments: {
+                projectId: input.projectId,
+                ...(input.language ? { language: input.language } : {}),
+            },
+        });
+        const record = await service.questionnaireResume({
+            repoRoot: input.repoRoot,
+            questionnaireId,
+        });
+        if (record.status !== 'answered')
+            return form;
+        if (record.answer?.choice !== 'approve')
+            return output({
+                ok: true,
+                data: {
+                    moved: false,
+                    status: 'declined',
+                    nextAction: 'The project was not moved and nothing changed. Tell the user in one line. If they later want the move, call project.move_repository with decisionAttempt ' +
+                        ((input.decisionAttempt ?? 0) + 1) +
+                        '.',
+                },
+            });
+        return output(await service.projectMoveRepository({
+            repoRoot: input.repoRoot,
+            projectId: input.projectId,
+            expectedVersion: flight.history.lockVersion,
+        }));
+    });
     server.registerTool('memory.source_targets', {
         description: 'Read bounded Git ref candidates without assuming environment roles from their names. Confirm only the chosen committed sources with native memory.sync_start questionnaires; an explicit ref can select a source outside this preview.',
         inputSchema: z.object({ repoRoot: z.string().optional() }),
@@ -163,11 +475,11 @@ export function registerOnboardingTools(server, service) {
         inputSchema: z.object({ repoRoot }),
     }, async (input) => output(await service.projectInspect(input)));
     server.registerTool('project.onboard', {
-        description: 'Choose greenfield, adopt, rework or refresh through durable native forms, then approve a stack-specific profile: palette, fonts/text styles, Figma, navigation, ready services and accessible backend links, or backend API/storage/migrations/environment choices. The agent proposes values from evidence and user answers; never invent defaults. The exact choice persists outside the repository and, with projectId, in the project onboarding record. This does not activate an engineering-memory revision.',
+        description: 'Choose greenfield, adopt, rework or refresh through durable native forms, then approve a stack-specific profile: palette, fonts/text styles, Figma, navigation, ready services and accessible backend links, or backend API/storage/migrations/environment choices. The agent proposes values from evidence and user answers; never invent defaults. Pass language as the BCP-47 tag of the language the user writes in; it is remembered. The exact choice persists outside the repository and, with projectId, in the project onboarding record. This does not activate an engineering-memory revision.',
         inputSchema: onboardingInput,
     }, async (input, context) => approveOnboarding(server, service, input, context, false));
     server.registerTool('project.initialize', {
-        description: 'Choose the onboarding mode and profile through native forms before creating a folder or Git. Only an approved greenfield choice initializes Git; preserves existing files, including barely-started projects. Other choices return without changing source. Use the exact same requestKey/profile for retries.',
+        description: 'Choose the onboarding mode and profile through native forms before creating a folder or Git. Only an approved greenfield choice initializes Git; preserves existing files, including barely-started projects. Other choices return without changing source. Pass language as the BCP-47 tag of the language the user writes in; it is remembered. Use the exact same requestKey/profile for retries.',
         inputSchema: onboardingInput,
     }, async (input, context) => approveOnboarding(server, service, input, context, true));
     server.registerTool('project.onboarding_status', {
@@ -200,10 +512,11 @@ export function registerOnboardingTools(server, service) {
             preparation: true,
         })));
     server.registerTool('project.rework_plan', {
-        description: 'After completed deep learning and approved target-architecture revisions, approve an exact phased plan through a native form. Materializes real dependency-ordered WorkItems atomically and idempotently. Each phase names inspected units and a branch; later implementation uses existing task.branch/worktrees and each repository lifecycle. No source changes happen here.',
+        description: 'After completed deep learning and approved target-architecture revisions, approve an exact phased plan through a native form. Materializes real dependency-ordered WorkItems atomically and idempotently. Each phase names inspected units and a branch; later implementation uses existing task.branch/worktrees and each repository lifecycle. Pass language as the BCP-47 tag of the language the user writes in; it is remembered. No source changes happen here.',
         inputSchema: z.strictObject({
             ...run,
             repoRoot,
+            language: languageTag.optional(),
             onboardingId: uuid,
             requestKey: z.string().regex(/^[A-Za-z0-9_-]{1,80}$/),
             targetRevisions: z
@@ -224,19 +537,49 @@ export function registerOnboardingTools(server, service) {
                 .max(100),
         }),
     }, async (input, context) => {
-        const { repoRoot: root, ...plan } = input;
+        const { repoRoot: root, language: told, ...plan } = input;
+        const language = (await service.language(told))?.startsWith('tr') ? 'tr' : 'en';
         const digest = sha256(stableStringify(plan));
-        const answer = await askQuestionnaire(server, service, {
-            repoRoot: root,
-            questionnaireId: 'rework-' + digest,
-            message: 'Approve the phased rework plan already presented in full, including target revisions, units, acceptance criteria and branches? Digest: ' +
-                digest +
-                '. Creates work items only; each implementation needs its normal branch/worktree lifecycle.',
-            options: [
-                { id: 'approve', label: 'Create these exact phases' },
-                { id: 'defer', label: 'Keep the plan for further review' },
-            ],
-        }, context);
+        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, [
+            ...definitions,
+            {
+                questionnaireId,
+                message: 'Approve the phased rework plan already presented in full, including target revisions, units, acceptance criteria and branches? Digest: ' +
+                    digest +
+                    '. Creates work items only; each implementation needs its normal branch/worktree lifecycle.',
+                options: [
+                    { id: 'approve', label: 'Create these exact phases' },
+                    { id: 'defer', label: 'Keep the plan for further review' },
+                ],
+            },
+        ]);
         if (answerChoice(answer) !== 'approve')
             return answer;
         return output(await service.onboardingRequest('rework', body(plan)));
@@ -257,16 +600,13 @@ export function registerOnboardingTools(server, service) {
         }),
     }, async (input) => output(await service.memorySource(input)));
     server.registerTool('memory.sync_start', {
-        description: 'Start or resume an idempotent committed-source inspection after native mode approval. Set language from the current conversation (tr or en), never from machine locale. Uploads all manifest pages, including exclusions. Request key and source are immutable. Refresh references a completed earlier run; rework requires preserve/redesign. Analyze with the current agent; no backend LLM.',
+        description: 'Start or resume an idempotent committed-source inspection after native mode approval. Pass language as the BCP-47 tag of the language the user writes in, never the machine locale; it is remembered. Uploads all manifest pages, including exclusions. Request key and source are immutable. Refresh references a completed earlier run; rework requires preserve/redesign. Analyze with the current agent; no backend LLM.',
         inputSchema: z.object({
             ...project,
             repoRoot,
             requestKey: z.string().regex(/^[a-zA-Z0-9_-]{1,120}$/),
             mode: z.enum(['adopt', 'refresh', 'rework']),
-            language: z
-                .enum(['tr', 'en'])
-                .optional()
-                .describe('Use the current conversation language: tr for Turkish, en for English. Omitted by legacy callers means English.'),
+            language: languageTag.optional(),
             ref: z.string().optional(),
             baseSnapshotId: uuid.optional(),
             previousRunId: uuid.optional(),
@@ -291,7 +631,8 @@ export function registerOnboardingTools(server, service) {
                     recovery: 'memory.sync_status',
                 },
             });
-        const { language = 'en', ...request } = input;
+        const { language: told, ...request } = input;
+        const language = (await service.language(told))?.startsWith('tr') ? 'tr' : 'en';
         const pinned = { ...request, ref: commit };
         const digest = sha256(stableStringify(pinned));
         const reference = input.ref ?? 'HEAD';
@@ -299,6 +640,24 @@ export function registerOnboardingTools(server, service) {
             ? 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,
@@ -320,6 +679,7 @@ export function registerOnboardingTools(server, service) {
         const definition = definitions.find((entry) => entry.language === language);
         const question = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot }, context, [
             ...definitions,
+            ...previousWording,
             {
                 questionnaireId: 'sync-start-' + digest,
                 message: 'Start ' +
@@ -487,40 +847,69 @@ export function registerOnboardingTools(server, service) {
         }),
     }, async (input) => output(await service.onboardingRequest('read_revisions', body(input))));
     server.registerTool('memory.review_batch', {
-        description: 'After presenting full module proposal contents, evidence, uncertainties and archive actions through memory.list_proposals, collect native approval for these exact proposal ids, hashes and base revisions. Pending/dismissed forms never write. All reviews commit atomically; stale revisions fail.',
+        description: 'Collect native approval for these exact proposal ids, hashes and base revisions. The form shows each record by title, kind, scope, revision and reason; present the full contents through memory.list_proposals first when the user has not seen them. A form holds at most eight records: review a larger set as separate calls of eight or fewer. Pass language as the BCP-47 tag of the language the user writes in; it is remembered. Pending/dismissed forms never write. Stale revisions fail.',
         inputSchema: z.strictObject({
             ...project,
             repoRoot,
-            entries: z.array(reference).min(1).max(20),
+            entries: z.array(reference).min(1).max(8),
             reviewAttempt: z.number().int().min(0).max(10000).default(0),
+            language: languageTag.optional(),
         }),
     }, async (input, context) => {
         const entries = [...input.entries].sort((a, b) => a.proposalId.localeCompare(b.proposalId));
         const digest = sha256(stableStringify({ projectId: input.projectId, entries }));
-        const result = await askQuestionnaire(server, service, {
+        const question = {
             repoRoot: input.repoRoot,
-            questionnaireId: 'memory-batch-' + digest + '-' + input.reviewAttempt,
-            message: 'Review the exact module batch already presented in full. Batch digest: ' +
-                digest +
-                '\nProposals:\n' +
-                entries.map((e) => e.proposalId).join('\n') +
-                '\nApprove publishes the listed contents; reject leaves active memory unchanged.',
-            options: [
-                { id: 'approved', label: 'Approve this exact batch' },
-                { id: 'rejected', label: 'Reject this exact batch' },
-                { id: 'defer', label: 'Leave these proposals pending' },
-            ],
-        }, context);
+            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 stored = await service.questionnaireResume(question).catch(() => undefined);
+        let result;
+        if (stored && stableStringify(stored.binding) === stableStringify(binding))
+            result = await resumeQuestionnaire(server, service, question, context);
+        else {
+            const pending = new Map();
+            for (let afterId;;) {
+                const page = await service.memoryListProposals({
+                    projectId: input.projectId,
+                    limit: 100,
+                    afterId,
+                });
+                if (!page.ok)
+                    return output(page);
+                const data = page.data;
+                for (const proposal of data.proposals)
+                    pending.set(proposal.proposalId, proposal);
+                if (!data.nextAfterId || entries.every((entry) => pending.has(entry.proposalId)))
+                    break;
+                afterId = data.nextAfterId;
+            }
+            const proposals = entries.flatMap((entry) => pending.get(entry.proposalId) ?? []);
+            if (proposals.length !== entries.length || proposals.some((p) => !p.reviewableByCaller))
+                return output({
+                    ok: false,
+                    error: {
+                        kind: 'bridge_error',
+                        message: 'Some of these proposals are no longer pending or cannot be reviewed by this account. List the pending proposals again with memory.list_proposals and send the entries it returns. Nothing was changed.',
+                        retryable: false,
+                        recovery: 'memory.list_proposals',
+                    },
+                });
+            result = await askQuestionnaire(server, service, { ...question, language, ...batchQuestion(language === 'tr', proposals), binding }, context);
+        }
         const decision = answerChoice(result);
-        if (decision === 'defer')
+        if (decision === 'defer' || decision === 'one_by_one')
             return output({
                 ok: true,
                 data: {
-                    status: 'deferred',
+                    status: decision === 'defer' ? 'deferred' : 'one_by_one',
                     digest,
                     reviewAttempt: input.reviewAttempt,
                     nextReviewAttempt: input.reviewAttempt + 1,
-                    nextAction: 'When the user is ready to review again, call memory.review_batch with the same exact entries and nextReviewAttempt as reviewAttempt. Retrying this attempt preserves the deferral.',
+                    nextAction: decision === 'defer'
+                        ? 'When the user is ready to review again, call memory.review_batch with the same exact entries and nextReviewAttempt as reviewAttempt. Retrying this attempt preserves the deferral.'
+                        : 'Nothing was published. Show each record in full with memory.list_proposals, then collect the approval of each one with its own memory.review_batch call holding that single entry. Never call memory.review_proposal without that native approval.',
                 },
             });
         if (decision !== 'approved' && decision !== 'rejected')
@@ -533,22 +922,299 @@ 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.',
+            ],
+        },
+    },
+};
 async function approveOnboarding(server, service, input, context, initialize) {
     const preparation = !input.projectId;
     const scope = { repoRoot: input.repoRoot, preparation };
-    const mode = await askQuestionnaire(server, service, {
-        ...scope,
-        questionnaireId: 'onboard-mode-' + sha256(input.requestKey),
-        message: 'Based on project.inspect, choose how this project should enter Engineering Memory. Choosing an existing architecture never rewrites it.',
-        options: [
-            { id: 'greenfield', label: 'Set up a new or barely-started project' },
-            { id: 'adopt', label: 'Learn and preserve the existing architecture' },
-            { id: 'rework', label: 'Learn first, then plan a phased rework' },
-            ...(input.projectId
-                ? [{ id: 'refresh', label: 'Refresh memory against the current project' }]
-                : []),
-        ],
-    }, context);
+    const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
+    const modeId = 'onboard-mode-' + sha256(input.requestKey);
+    const modeDefinitions = ['tr', 'en'].map((displayLanguage) => {
+        const copy = onboardingCopy[displayLanguage].mode;
+        return {
+            questionnaireId: modeId,
+            language: displayLanguage,
+            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] },
+                ...(input.projectId
+                    ? [{ id: 'refresh', label: copy.refresh[0], description: copy.refresh[1] }]
+                    : []),
+            ],
+        };
+    });
+    const mode = await askQuestionnaire(server, service, { ...scope, ...modeDefinitions.find((entry) => entry.language === language) }, context, [
+        ...modeDefinitions,
+        {
+            questionnaireId: modeId,
+            message: 'Based on project.inspect, choose how this project should enter Engineering Memory. Choosing an existing architecture never rewrites it.',
+            options: [
+                { id: 'greenfield', label: 'Set up a new or barely-started project' },
+                { id: 'adopt', label: 'Learn and preserve the existing architecture' },
+                { id: 'rework', label: 'Learn first, then plan a phased rework' },
+                ...(input.projectId
+                    ? [{ id: 'refresh', label: 'Refresh memory against the current project' }]
+                    : []),
+            ],
+        },
+    ]);
     const selected = answerChoice(mode);
     if (!selected)
         return mode;
@@ -561,15 +1227,32 @@ async function approveOnboarding(server, service, input, context, initialize) {
             },
         });
     if (selected === 'rework') {
-        const behavior = await askQuestionnaire(server, service, {
-            ...scope,
-            questionnaireId: 'rework-behavior-' + sha256(input.requestKey),
-            message: 'Should rework preserve current observable behavior or redesign the product? Redesign requires approved target screens, flows and contracts before implementation.',
-            options: [
-                { id: 'preserve', label: 'Preserve current behavior' },
-                { id: 'redesign', label: 'Redesign the product explicitly' },
-            ],
-        }, context);
+        const behaviorId = 'rework-behavior-' + sha256(input.requestKey);
+        const behaviorDefinitions = ['tr', 'en'].map((displayLanguage) => {
+            const copy = onboardingCopy[displayLanguage].behavior;
+            return {
+                questionnaireId: behaviorId,
+                language: displayLanguage,
+                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] },
+                ],
+            };
+        });
+        const behavior = await askQuestionnaire(server, service, { ...scope, ...behaviorDefinitions.find((entry) => entry.language === language) }, context, [
+            ...behaviorDefinitions,
+            {
+                questionnaireId: behaviorId,
+                message: 'Should rework preserve current observable behavior or redesign the product? Redesign requires approved target screens, flows and contracts before implementation.',
+                options: [
+                    { id: 'preserve', label: 'Preserve current behavior' },
+                    { id: 'redesign', label: 'Redesign the product explicitly' },
+                ],
+            },
+        ]);
         const chosen = answerChoice(behavior);
         if (!chosen)
             return behavior;
@@ -587,7 +1270,7 @@ async function approveOnboarding(server, service, input, context, initialize) {
     const processedFields = new Set();
     let fields = profileFields(effectiveProfile);
     for (let index = 0; index < fields.length; index += 1) {
-        const [field, label] = fields[index];
+        const field = fields[index];
         if (processedFields.has(field))
             continue;
         const currentValue = effectiveProfile[field] ?? null;
@@ -598,31 +1281,66 @@ async function approveOnboarding(server, service, input, context, initialize) {
             field,
             currentValue,
         }));
-        const response = await askQuestionnaire(server, service, {
-            ...scope,
-            questionnaireId: 'onboard-field-' + field + '-' + digest,
-            message: 'Review this onboarding choice before it is persisted.\n' +
-                'Field: ' +
-                label +
-                '\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.',
-            options: profileFieldOptions(field, currentValue),
-            ...(field === 'stack'
-                ? {}
-                : {
-                    textField: {
-                        title: field === 'backendProjectIds' ? 'Project ID JSON array' : 'Edited value',
-                        maxLength: field === 'backendProjectIds'
-                            ? 2000
-                            : ['architecture', 'colorPalette', 'typography'].includes(field)
-                                ? 240
-                                : 160,
-                        requiredForChoice: 'edit_value',
-                        ...(field === 'backendProjectIds' ? { valueType: 'uuid_list' } : {}),
-                    },
-                }),
-        }, context);
+        const fieldId = 'onboard-field-' + field + '-' + digest;
+        const written = Array.isArray(currentValue)
+            ? currentValue.join(', ')
+            : typeof currentValue === 'string'
+                ? currentValue
+                : '';
+        const textField = field === 'stack'
+            ? undefined
+            : {
+                maxLength: field === 'backendProjectIds'
+                    ? 2000
+                    : ['architecture', 'colorPalette', 'typography'].includes(field)
+                        ? 240
+                        : 160,
+                requiredForChoice: 'edit_value',
+                ...(field === 'backendProjectIds' ? { valueType: 'uuid_list' } : {}),
+            };
+        const fieldDefinitions = ['tr', 'en'].map((displayLanguage) => {
+            const copy = onboardingCopy[displayLanguage].field;
+            return {
+                questionnaireId: fieldId,
+                language: displayLanguage,
+                message: [
+                    profileFieldNames[displayLanguage][field],
+                    `${copy.value}: ${written || copy.empty}`,
+                ].join('\n'),
+                context: copy.context,
+                example: copy.example,
+                options: profileFieldOptions(field, currentValue, copy),
+                ...(textField
+                    ? {
+                        textField: {
+                            title: field === 'backendProjectIds' ? copy.idsTitle : copy.editTitle,
+                            ...textField,
+                        },
+                    }
+                    : {}),
+            };
+        });
+        const response = await askQuestionnaire(server, service, { ...scope, ...fieldDefinitions.find((entry) => entry.language === language) }, context, [
+            ...fieldDefinitions,
+            {
+                questionnaireId: fieldId,
+                message: 'Review this onboarding choice before it is persisted.\n' +
+                    'Field: ' +
+                    profileFieldNames.en[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.',
+                options: legacyProfileFieldOptions(field, currentValue),
+                ...(textField
+                    ? {
+                        textField: {
+                            title: field === 'backendProjectIds' ? 'Project ID JSON array' : 'Edited value',
+                            ...textField,
+                        },
+                    }
+                    : {}),
+            },
+        ]);
         const answer = answerData(response);
         const choice = answer?.choice;
         if (!choice)
@@ -647,24 +1365,49 @@ async function approveOnboarding(server, service, input, context, initialize) {
     if (preparation && service.managesWorktrees()) {
         gitPreferences = {};
         for (const role of ['development', 'production', 'test']) {
-            const response = await askQuestionnaire(server, service, {
-                ...scope,
-                questionnaireId: 'onboard-git-' + role + '-' + sha256(input.requestKey),
-                message: role === 'development'
-                    ? 'Which development branch should new task branches start from? For a new repository, choose its planned initial branch name. This choice uses the origin remote after it is connected.'
-                    : 'Which ' +
-                        role +
-                        ' branch does this project use? Choose explicitly none if there is no such branch yet; you will not be asked again.',
-                options: [
-                    { id: 'set', label: 'Use the branch named below' },
-                    ...(role === 'development'
-                        ? [{ id: 'defer', label: 'Do not start setup yet' }]
-                        : [{ id: 'none', label: 'No ' + role + ' branch yet' }]),
-                ],
-                textField: { title: 'Branch name', maxLength: 255, requiredForChoice: 'set' },
-                allowFreeText: false,
-            }, context);
+            const branchId = 'onboard-git-' + role + '-' + sha256(input.requestKey);
+            const branchDefinitions = ['tr', 'en'].map((displayLanguage) => {
+                const copy = onboardingCopy[displayLanguage].git;
+                return {
+                    questionnaireId: branchId,
+                    language: displayLanguage,
+                    message: copy[role].message,
+                    context: copy[role].context,
+                    example: copy[role].example,
+                    options: [
+                        { id: 'set', label: copy.set[0], description: copy.set[1] },
+                        {
+                            id: role === 'development' ? 'defer' : 'none',
+                            label: copy[role].second[0],
+                            description: copy[role].second[1],
+                        },
+                    ],
+                    textField: { title: copy.branchTitle, maxLength: 255, requiredForChoice: 'set' },
+                    allowFreeText: false,
+                };
+            });
+            const response = await askQuestionnaire(server, service, { ...scope, ...branchDefinitions.find((entry) => entry.language === language) }, context, [
+                ...branchDefinitions,
+                {
+                    questionnaireId: branchId,
+                    message: role === 'development'
+                        ? 'Which development branch should new task branches start from? For a new repository, choose its planned initial branch name. This choice uses the origin remote after it is connected.'
+                        : 'Which ' +
+                            role +
+                            ' branch does this project use? Choose explicitly none if there is no such branch yet; you will not be asked again.',
+                    options: [
+                        { id: 'set', label: 'Use the branch named below' },
+                        ...(role === 'development'
+                            ? [{ id: 'defer', label: 'Do not start setup yet' }]
+                            : [{ id: 'none', label: 'No ' + role + ' branch yet' }]),
+                    ],
+                    textField: { title: 'Branch name', maxLength: 255, requiredForChoice: 'set' },
+                    allowFreeText: false,
+                },
+            ]);
             const answer = answerData(response);
+            if (answer?.choice === 'defer')
+                return deferredProfile(input.requestKey, 'git-' + role);
             if (answer?.choice !== 'none' && (answer?.choice !== 'set' || !answer.text))
                 return response;
             gitPreferences[role] = {
@@ -683,21 +1426,42 @@ async function approveOnboarding(server, service, input, context, initialize) {
     };
     const digest = sha256(stableStringify(choice));
     const questionnaireId = 'onboard-profile-' + digest + (initialize ? '-initialize' : '-save');
-    const approval = await askQuestionnaire(server, service, {
-        ...scope,
-        questionnaireId,
-        message: 'Save the selected mode and the profile choices just reviewed? Mode: ' +
-            input.mode +
-            '. Exact choice digest: ' +
-            digest +
-            '. ' +
-            (initialize ? 'Greenfield will prepare Git without replacing existing files. ' : '') +
-            'Engineering-memory revisions and project links require their own review/authority.',
-        options: [
-            { id: 'approve', label: 'Save these exact onboarding choices' },
-            { id: 'defer', label: 'Keep the choices pending' },
-        ],
-    }, context);
+    const saveDefinitions = ['tr', 'en'].map((displayLanguage) => {
+        const copy = onboardingCopy[displayLanguage].save;
+        return {
+            questionnaireId,
+            language: displayLanguage,
+            message: [copy.message, `${copy.routeLabel}: ${copy.route[input.mode]}`].join('\n'),
+            context: copy.context + (initialize ? copy.git : ''),
+            example: copy.example,
+            options: [
+                {
+                    id: 'approve',
+                    label: copy.approve[0],
+                    description: initialize ? copy.approveGit : copy.approve[1],
+                },
+                { id: 'defer', label: copy.defer[0], description: copy.defer[1] },
+            ],
+            binding: { choiceDigest: digest },
+        };
+    });
+    const approval = await askQuestionnaire(server, service, { ...scope, ...saveDefinitions.find((entry) => entry.language === language) }, context, [
+        ...saveDefinitions,
+        {
+            questionnaireId,
+            message: 'Save the selected mode and the profile choices just reviewed? Mode: ' +
+                input.mode +
+                '. Exact choice digest: ' +
+                digest +
+                '. ' +
+                (initialize ? 'Greenfield will prepare Git without replacing existing files. ' : '') +
+                'Engineering-memory revisions and project links require their own review/authority.',
+            options: [
+                { id: 'approve', label: 'Save these exact onboarding choices' },
+                { id: 'defer', label: 'Keep the choices pending' },
+            ],
+        },
+    ]);
     if (answerChoice(approval) === 'defer')
         return deferredProfile(input.requestKey, 'final-profile');
     if (answerChoice(approval) !== 'approve')
@@ -743,7 +1507,29 @@ function parseEditedProfileValue(field, value) {
     return z.array(uuid).max(10).parse(parsed);
 }
 const stackValues = ['Flutter', 'React', 'Nest', 'Spring'];
-function profileFieldOptions(field, currentValue) {
+function profileFieldOptions(field, currentValue, copy) {
+    if (field === 'stack') {
+        return [
+            { id: 'keep_current', label: copy.keep[0], description: copy.keep[1] },
+            ...stackValues
+                .filter((value) => value !== currentValue)
+                .map((value) => ({
+                id: value,
+                label: copy.change(value),
+                description: copy.changeDetail(value),
+            })),
+            { id: 'defer_current', label: copy.defer[0], description: copy.defer[1] },
+        ];
+    }
+    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] },
+    ];
+}
+function legacyProfileFieldOptions(field, currentValue) {
     if (field === 'stack') {
         return [
             { id: 'keep_current', label: 'Keep this exact value' },
@@ -761,20 +1547,20 @@ function profileFieldOptions(field, currentValue) {
 }
 function profileFields(profileValue) {
     const fields = [
-        ['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'],
+        'stack',
+        'runtime',
+        'architecture',
+        'environments',
+        'serviceReadiness',
+        'apiContract',
+        'authentication',
+        'storage',
+        'backendProjectIds',
     ];
     if (['Nest', 'Spring'].includes(profileValue.stack))
-        fields.push(['migrations', 'Migration strategy']);
+        fields.push('migrations');
     if (['Flutter', 'React'].includes(profileValue.stack)) {
-        fields.push(['figma', 'Figma source'], ['colorPalette', 'Color palette'], ['typography', 'Font families and text styles'], ['designSystem', 'Design system'], ['navigation', 'Navigation'], ['platforms', 'Platforms'], ['localization', 'Localization languages']);
+        fields.push('figma', 'colorPalette', 'typography', 'designSystem', 'navigation', 'platforms', 'localization');
     }
     return fields;
 }