engineering-memory 1.11.20 → 1.11.21

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

@@ -7,6 +7,7 @@ import { sha256, stableStringify } from '../utilities/hash.js';
 import { unreadableWorktree } from '../runtime/worktree-pool.js';
 import { askFailed, askQuestionnaire } from './questionnaire-tools.js';
 import { languageTag } from '../runtime/questionnaire-store.js';
+import { copies, format } from '../runtime/texts.js';
 const repo = z.string().min(1);
 const branch = z.string().min(1).max(255);
 const remote = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/);
@@ -51,170 +52,76 @@ const policy = {
     heartbeatSeconds: z.number().int().min(5).max(300),
     inactivitySeconds: z.number().int().min(60).max(86400),
 };
-const preferenceCopy = {
-    en: {
-        message: 'Save the shared branch preferences of this project? Nothing is saved until you answer.',
-        context: 'These branches belong to the whole project: every member who starts a task here is offered them as the branch the task starts from. Only a project or organization administrator can change them. No branch is created, moved or deleted; only the preference is recorded.',
-        example: 'Once the development role points at origin/develop, the start form of the next task offers origin/develop as its first choice.',
-        roles: { development: 'development', production: 'production', test: 'test' },
-        ask: (role, source) => source
-            ? `Save ${source} as the shared ${role} branch?`
-            : `Record that this project has no ${role} branch?`,
-        save: 'Save this choice',
-        saved: 'This branch is recorded as the project default now, for every member.',
-        leave: 'Leave unchanged',
-        unchanged: 'Nothing changes. This role stays as it is and can be answered another time.',
-    },
-    tr: {
-        message: 'Projenin ortak dal tercihleri kaydedilsin mi? Sen cevaplayana kadar hiçbir şey kaydedilmez.',
-        context: 'Bu dallar projenin tamamı için geçerli: burada görev başlatan herkese, görevin başlayacağı dal olarak bunlar önerilir. Yalnızca proje ya da organizasyon yöneticisi değiştirebilir. Hiçbir dal oluşturulmaz, taşınmaz veya silinmez; yalnızca tercih kaydedilir.',
-        example: 'Geliştirme dalı origin/develop olarak kaydedilirse, bir sonraki görevin başlangıç formunda ilk seçenek origin/develop olur.',
-        roles: { development: 'Geliştirme', production: 'Canlı', test: 'Test' },
-        ask: (role, source) => source
-            ? `${role} dalı ${source} olarak kaydedilsin mi?`
-            : `Bu projede ${role.toLocaleLowerCase('tr')} dalı olmadığı kaydedilsin mi?`,
-        save: 'Bu tercihi kaydet',
-        saved: 'Bu dal şimdi proje varsayılanı olarak kaydedilir; ekipteki herkes onu görür.',
-        leave: 'Şimdilik değiştirme',
-        unchanged: 'Hiçbir şey değişmez. Bu rol olduğu gibi kalır, sonra yeniden sorulabilir.',
-    },
-};
-const fallbackCopy = {
-    en: {
-        message: (remote, local, inPlace) => `The remote ${remote} could not be fetched. Should the task start from local ${local} ${inPlace ? 'in this folder' : 'in a separate worktree'}?`,
-        context: 'The branch you chose cannot be reached, so its exact commit is unavailable. The local copy is whatever was fetched last: commits pushed to the remote since then are not in it. Nothing is created until you answer.',
-        example: (remote, local) => `Continuing creates the new branch at ${local}; ${remote} can be merged into it once the network is back.`,
-        approve: 'Continue',
-        approved: (local) => `The new branch is created at ${local} now and the task starts.`,
-        defer: 'Not now',
-        deferred: 'Nothing is created or reserved. The task waits, and it can be started again once the remote answers.',
-    },
-    tr: {
-        message: (remote, local, inPlace) => `${remote} uzak dalına ulaşılamadı. Görev, yereldeki ${local} üzerinden ${inPlace ? 'bu klasörde' : 'ayrı bir worktree’de'} başlasın mı?`,
-        context: 'Seçtiğin dala ulaşılamadığı için tam commit’i alınamıyor. Yerel kopya, en son çekilen hâli gösterir: o günden sonra uzak dala giden commit’ler burada yok. Sen cevaplayana kadar hiçbir şey oluşturulmaz.',
-        example: (remote, local) => `Devam edersen yeni dal ${local} üzerinden açılır; ağ düzeldiğinde ${remote} dalını bu dala birleştirebilirsin.`,
-        approve: 'Devam et',
-        approved: (local) => `Yeni dal şimdi ${local} üzerinden açılır ve görev başlar.`,
-        defer: 'Şimdilik başlatma',
-        deferred: 'Hiçbir şey oluşturulmaz, hiçbir yer ayrılmaz. Görev bekler; uzak dala ulaşıldığında yeniden başlatılabilir.',
-    },
-};
-const forgetCopy = {
-    en: {
-        message: (task, folder) => `The ${folder} folder of task ${task} can no longer be read as a Git checkout. Should Engineering Memory stop tracking it?`,
-        context: (pendingDelivery) => 'A checkout that cannot be read is still counted against the worktree limit although nothing can use it; forgetting it frees that slot. No file in the folder is touched or deleted, and the branch stays.' +
-            (pendingDelivery
-                ? ' That task closed without its delivery being settled, so any undelivered work exists only in that folder.'
-                : ''),
-        example: (task, folder) => `After this, ${task} no longer appears in the worktree list and the ${folder} folder stays on disk exactly as it is.`,
-        forget: 'Stop tracking it; leave the files alone',
-        forgotten: 'The record is removed and the slot is free again. The folder, its files and its branch stay untouched.',
-        keep: 'Keep tracking it',
-        kept: 'Nothing changes. The record stays and keeps counting against the limit.',
-    },
-    tr: {
-        message: (task, folder) => `${task} görevinin ${folder} klasörü artık bir Git çalışma kopyası olarak okunamıyor. Engineering Memory bu klasörü takip etmeyi bıraksın mı?`,
-        context: (pendingDelivery) => 'Okunamayan bir çalışma kopyası hiçbir işe yaramadığı hâlde worktree sınırına sayılmaya devam eder; takipten çıkarılırsa o yer boşalır. Klasördeki hiçbir dosyaya dokunulmaz, hiçbiri silinmez; dal da kalır.' +
-            (pendingDelivery
-                ? ' Bu görev teslimi sonuçlanmadan kapandı; teslim edilmemiş iş varsa yalnızca bu klasörde duruyor.'
-                : ''),
-        example: (task, folder) => `Bundan sonra ${task} worktree listesinde görünmez, ${folder} klasörü ise diskte olduğu gibi kalır.`,
-        forget: 'Takip etmeyi bırak; dosyalara dokunma',
-        forgotten: 'Kayıt silinir ve sınırdaki yer boşalır. Klasör, içindeki dosyalar ve dal olduğu gibi kalır.',
-        keep: 'Takip etmeye devam et',
-        kept: 'Hiçbir şey değişmez. Kayıt durur ve sınıra sayılmaya devam eder.',
-    },
-};
-const retireCopy = {
-    en: {
-        missing: (folder) => `The ${folder} folder is gone but its worktree record is still here. Remove the record?`,
-        message: (folder, branch) => `${folder} is a worktree left in the old location (branch ${branch}). Remove the folder?`,
-        context: (missing) => 'Folders in the old location are no longer part of the pool: they are never reused and do not count toward the limit.' +
-            (missing
-                ? ' Only the record is left, so there is no folder to remove and no file is read or deleted.'
-                : ' The branch and its commits stay. Git removes only a clean folder, and the files it ignores go with it.'),
-        example: (folder, branch, missing) => missing
-            ? `After this, ${folder} is gone from the worktree list and nothing on disk changes.`
-            : `After this, ${folder} is gone from the worktree list and branch ${branch} still holds every commit made on it.`,
-        retire: 'Remove the folder',
-        retired: (missing) => missing
-            ? 'The stale record is removed. Nothing on disk changes.'
-            : 'Git removes the folder and Engineering Memory drops its record. The branch and its commits stay.',
-        keep: 'Keep it',
-        kept: 'Nothing changes. The folder and its record stay exactly as they are.',
-    },
-    tr: {
-        missing: (folder) => `${folder} klasörü artık yok ama worktree kaydı duruyor. Kayıt silinsin mi?`,
-        message: (folder, branch) => `${folder}, eski konumda kalmış bir worktree (dal ${branch}). Klasör kaldırılsın mı?`,
-        context: (missing) => 'Eski konumdaki klasörler artık havuzun parçası değil: yeniden kullanılmıyorlar ve sınıra da sayılmıyorlar.' +
-            (missing
-                ? ' Geriye yalnızca kayıt kaldı; kaldırılacak bir klasör yok, hiçbir dosya okunmaz veya silinmez.'
-                : ' Dal ve üzerindeki commit’ler kalır. Git yalnızca temiz bir klasörü kaldırır; kaldırırken .gitignore kapsamındaki dosyalar da gider.'),
-        example: (folder, branch, missing) => missing
-            ? `Bundan sonra ${folder} worktree listesinde görünmez; diskte hiçbir şey değişmez.`
-            : `Bundan sonra ${folder} worktree listesinde görünmez; ${branch} dalındaki commit’ler ise yerinde durur.`,
-        retire: 'Klasörü kaldır',
-        retired: (missing) => missing
-            ? 'Boşta kalan kayıt silinir. Diskte hiçbir şey değişmez.'
-            : 'Git klasörü kaldırır, Engineering Memory de kaydını siler. Dal ve commit’ler kalır.',
-        keep: 'Kalsın',
-        kept: 'Hiçbir şey değişmez. Klasör de kaydı da olduğu gibi kalır.',
-    },
-};
-const unownedCopy = {
-    en: {
-        message: (folder) => `Nobody is recorded as using the ${folder} folder. If the agent that worked there has stopped and its delivery is finished, should the clean checkout become reusable?`,
-        context: 'This checkout was found without an ownership record, so it is protected and handed to no task. Releasing it runs the safety checks again first: a folder with uncommitted work is refused. No file and no branch is ever deleted.',
-        example: (commit) => `Once it is released, the next task can start in that folder, and the work committed at ${commit} stays on its branch.`,
-        release: 'Prior work finished; release after safety checks',
-        released: 'The safety checks run and, if they pass, the folder returns to the pool.',
-        preserve: 'Keep protected',
-        preserved: 'Nothing changes. The folder stays protected and is given to no task.',
-    },
-    tr: {
-        message: (folder) => `${folder} klasörünü kimin kullandığı kayıtlı değil. Burada çalışan ajan durduysa ve teslimi bittiyse, temiz klasör yeniden kullanılabilir hâle gelsin mi?`,
-        context: 'Bu çalışma kopyası sahiplik kaydı olmadan bulundu; bu yüzden korunuyor ve hiçbir göreve verilmiyor. Serbest bırakmadan önce güvenlik kontrolleri yeniden çalışır: kaydedilmemiş iş varsa işlem yapılmaz. Hiçbir dosya ve hiçbir dal silinmez.',
-        example: (commit) => `Serbest bırakılırsa sıradaki görev bu klasörde başlayabilir; ${commit} commit’ine kaydedilmiş iş dalında durmaya devam eder.`,
-        release: 'Önceki iş bitti; güvenlik kontrollerinden sonra kullanılabilir yap',
-        released: 'Güvenlik kontrolleri çalışır; geçerse klasör havuza döner.',
-        preserve: 'Korumaya devam et',
-        preserved: 'Hiçbir şey değişmez. Klasör korunur ve hiçbir göreve verilmez.',
-    },
-};
-const cancelCopy = {
-    en: {
-        message: (task) => `${task} will not be delivered. What should happen to this folder?`,
-        context: (clean, managed) => 'A cancelled delivery leaves the folder reserved for this task until you say what happens to it, and a reserved folder keeps counting against the worktree limit. The branch and every commit on it stay either way.' +
-            (clean
-                ? ''
-                : managed
-                    ? ' The folder has uncommitted changes; saving writes them to a Git ref they can be restored from.'
-                    : ' The folder has uncommitted changes; this is your own folder, so its files are never touched when it is freed.'),
-        example: 'Freeing the folder lets the next task start in it; keeping it leaves it reserved.',
-        release: 'Free the folder; the branch stays',
-        released: 'The folder returns to the pool. Its files are left alone and the branch stays.',
-        save: 'Save the changes and free the folder',
-        saved: 'The uncommitted changes are written to a Git ref first, then the folder is freed. They can be restored from that ref.',
-        keep: 'Keep the folder as it is',
-        kept: 'Nothing changes. The folder stays reserved for this task.',
-    },
-    tr: {
-        message: (task) => `${task} teslim edilmeyecek. Bu klasör ne olsun?`,
-        context: (clean, managed) => 'Teslimi iptal edilen bir klasör, sen ne olacağını söyleyene kadar bu göreve ayrılmış kalır ve ayrılmış klasör worktree sınırına sayılmaya devam eder. Dal ve üzerindeki commit’ler her hâlükârda durur.' +
-            (clean
-                ? ''
-                : managed
-                    ? ' Klasörde kaydedilmemiş değişiklikler var; kaydedilirse bir Git ref’ine yazılır ve oradan geri alınabilir.'
-                    : ' Klasörde kaydedilmemiş değişiklikler var; burası senin kendi klasörün olduğu için boşaltılsa da dosyalara dokunulmaz.'),
-        example: 'Klasör boşaltılırsa sıradaki görev burada başlayabilir; kalsın dersen bu göreve ayrılmış hâlde durur.',
-        release: 'Klasörü boşalt; branch kalsın',
-        released: 'Klasör havuza döner. Dosyalarına dokunulmaz, dal kalır.',
-        save: 'Değişiklikleri kaydedip klasörü boşalt',
-        saved: 'Kaydedilmemiş değişiklikler önce bir Git ref’ine yazılır, sonra klasör boşaltılır. Değişiklikler o ref’ten geri alınabilir.',
-        keep: 'Klasör olduğu gibi kalsın',
-        kept: 'Hiçbir şey değişmez. Klasör bu göreve ayrılmış hâlde kalır.',
-    },
-};
+const text = z.string().min(1);
+const roleTexts = z.strictObject({ development: text, production: text, test: text });
+const preferenceWording = z.strictObject({
+    message: text,
+    context: text,
+    example: text,
+    ask: roleTexts,
+    askNone: roleTexts,
+    save: text,
+    saved: text,
+    leave: text,
+    unchanged: text,
+});
+const fallbackWording = z.strictObject({
+    messageHere: text,
+    messageWorktree: text,
+    context: text,
+    example: text,
+    approve: text,
+    approved: text,
+    defer: text,
+    deferred: text,
+});
+const forgetWording = z.strictObject({
+    message: text,
+    context: text,
+    pendingDelivery: text,
+    example: text,
+    forget: text,
+    forgotten: text,
+    keep: text,
+    kept: text,
+});
+const retireWording = z.strictObject({
+    missing: text,
+    message: text,
+    noBranch: text,
+    context: text,
+    contextMissing: text,
+    contextFolder: text,
+    example: text,
+    exampleMissing: text,
+    retire: text,
+    retired: text,
+    retiredMissing: text,
+    keep: text,
+    kept: text,
+});
+const unownedWording = z.strictObject({
+    message: text,
+    context: text,
+    example: text,
+    release: text,
+    released: text,
+    preserve: text,
+    preserved: text,
+});
+const cancelWording = z.strictObject({
+    message: text,
+    context: text,
+    uncommittedManaged: text,
+    uncommittedOwn: text,
+    example: text,
+    release: text,
+    released: text,
+    save: text,
+    saved: text,
+    keep: text,
+    kept: text,
+});
 const baseSchema = z.discriminatedUnion('kind', [
     z.strictObject({
         kind: z.literal('current'),
@@ -266,7 +173,7 @@ export function registerWorktreeTools(server, service) {
             presentation,
         }),
     }, async (input, context) => {
-        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
+        const wording = copies(preferenceWording, 'gitPreferences', await service.language(input.language));
         const current = await service.projectGitPreferences(input);
         if (!current.ok)
             return output(current);
@@ -296,24 +203,26 @@ export function registerWorktreeTools(server, service) {
             ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
         }));
         const questionnaireId = 'project-branches-' + digest;
-        const definition = (turkish) => {
-            const copy = preferenceCopy[turkish ? 'tr' : 'en'];
-            return {
-                questionnaireId,
-                language: turkish ? 'tr' : 'en',
-                message: copy.message,
-                context: copy.context,
-                example: copy.example,
-                questions: roles.map((role) => ({
+        const definitions = wording.map(({ language, copy }) => ({
+            questionnaireId,
+            language,
+            message: copy.message,
+            context: copy.context,
+            example: copy.example,
+            questions: roles.map((role) => {
+                const branch = source(role, null);
+                return {
                     id: role,
-                    message: copy.ask(copy.roles[role], source(role, null)),
+                    message: branch
+                        ? format(copy.ask[role], language, { source: branch })
+                        : copy.askNone[role],
                     options: [
                         { id: 'approve', label: copy.save, description: copy.saved },
                         { id: 'defer', label: copy.leave, description: copy.unchanged },
                     ],
-                })),
-            };
-        };
+                };
+            }),
+        }));
         const previous = (turkish) => ({
             questionnaireId,
             language: turkish ? 'tr' : 'en',
@@ -347,10 +256,10 @@ export function registerWorktreeTools(server, service) {
             }),
         };
         const form = await askQuestionnaire(server, service, {
-            ...definition(language === 'tr'),
+            ...definitions[0],
             repoRoot: input.repoRoot,
             presentation: input.presentation,
-        }, context, [definition(language !== 'tr'), previous(true), previous(false)], owner);
+        }, context, [...definitions, previous(true), previous(false)], owner);
         if (askFailed(form))
             return form;
         const record = await service.questionnaireResume({
@@ -388,7 +297,7 @@ export function registerWorktreeTools(server, service) {
             presentation,
         }),
     }, async (input, context) => {
-        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
+        const told = await service.language(input.language);
         const preflight = await service.taskBranchPreflight(input);
         if (!preflight.ok)
             return output(preflight);
@@ -410,7 +319,11 @@ export function registerWorktreeTools(server, service) {
                     recovery: 'task.branch',
                 },
             });
-        const { previous, ...definition } = taskStartDefinition({ ...input, ...flight, language });
+        const { previous, ...definition } = taskStartDefinition({
+            ...input,
+            ...flight,
+            language: told ?? 'en',
+        });
         const owner = {
             tool: 'task.branch',
             externalTaskId: input.externalTaskId,
@@ -477,21 +390,25 @@ export function registerWorktreeTools(server, service) {
         const fallback = async () => {
             const from = sourceLabel(choice.base, flight.currentBranch);
             const local = sourceLabel(fallbackBase, flight.currentBranch);
-            const definition = (turkish) => {
-                const copy = fallbackCopy[turkish ? 'tr' : 'en'];
-                return {
-                    questionnaireId: fallbackId,
-                    language: turkish ? 'tr' : 'en',
-                    allowFreeText: false,
-                    message: copy.message(from, local, choice.inPlace),
-                    context: copy.context,
-                    example: copy.example(from, local),
-                    options: [
-                        { id: 'approve', label: copy.approve, description: copy.approved(local) },
-                        { id: 'defer', label: copy.defer, description: copy.deferred },
-                    ],
-                };
-            };
+            const definitions = copies(fallbackWording, 'startFallback', told).map(({ language, copy }) => ({
+                questionnaireId: fallbackId,
+                language,
+                allowFreeText: false,
+                message: format(choice.inPlace ? copy.messageHere : copy.messageWorktree, language, {
+                    remote: from,
+                    local,
+                }),
+                context: copy.context,
+                example: format(copy.example, language, { remote: from, local }),
+                options: [
+                    {
+                        id: 'approve',
+                        label: copy.approve,
+                        description: format(copy.approved, language, { local }),
+                    },
+                    { id: 'defer', label: copy.defer, description: copy.deferred },
+                ],
+            }));
             const previousFallback = (turkish) => ({
                 questionnaireId: fallbackId,
                 language: turkish ? 'tr' : 'en',
@@ -514,10 +431,10 @@ export function registerWorktreeTools(server, service) {
                 ],
             });
             const fallbackForm = await askQuestionnaire(server, service, {
-                ...definition(language === 'tr'),
+                ...definitions[0],
                 repoRoot: input.repoRoot,
                 presentation: input.presentation,
-            }, context, [definition(language !== 'tr'), previousFallback(true), previousFallback(false)], owner);
+            }, context, [...definitions, previousFallback(true), previousFallback(false)], owner);
             if (askFailed(fallbackForm))
                 return fallbackForm;
             const answer = await service.questionnaireResume({
@@ -571,7 +488,7 @@ export function registerWorktreeTools(server, service) {
             language: languageTag.optional(),
         }),
     }, async (input, context) => {
-        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
+        const told = await service.language(input.language);
         const inspection = await service.worktreeOperation('reconcile', input);
         if (!inspection.ok ||
             (!input.releaseUnowned && !input.retireLegacy && !input.forgetUnreadable))
@@ -590,21 +507,21 @@ export function registerWorktreeTools(server, service) {
                 });
             const questionnaireId = forgetUnreadableQuestionId(item, input.decisionAttempt);
             const folder = basename(item.repoRoot);
-            const definition = (turkish) => {
-                const copy = forgetCopy[turkish ? 'tr' : 'en'];
-                return {
-                    questionnaireId,
-                    language: turkish ? 'tr' : 'en',
-                    allowFreeText: false,
-                    message: copy.message(item.externalTaskId, folder),
-                    context: copy.context(item.pendingDelivery === true),
-                    example: copy.example(item.externalTaskId, folder),
-                    options: [
-                        { id: 'forget', label: copy.forget, description: copy.forgotten },
-                        { id: 'keep', label: copy.keep, description: copy.kept },
-                    ],
-                };
-            };
+            const named = { task: item.externalTaskId, folder };
+            const definitions = copies(forgetWording, 'forgetWorktree', told).map(({ language, copy }) => ({
+                questionnaireId,
+                language,
+                allowFreeText: false,
+                message: format(copy.message, language, named),
+                context: item.pendingDelivery
+                    ? `${copy.context} ${copy.pendingDelivery}`
+                    : copy.context,
+                example: format(copy.example, language, named),
+                options: [
+                    { id: 'forget', label: copy.forget, description: copy.forgotten },
+                    { id: 'keep', label: copy.keep, description: copy.kept },
+                ],
+            }));
             const previous = (turkish) => ({
                 questionnaireId,
                 language: turkish ? 'tr' : 'en',
@@ -635,7 +552,7 @@ export function registerWorktreeTools(server, service) {
                     { id: 'keep', label: turkish ? 'Takip etmeye devam et' : 'Keep tracking it' },
                 ],
             });
-            const form = await askQuestionnaire(server, service, { ...definition(language === 'tr'), repoRoot: input.repoRoot }, context, [definition(language !== 'tr'), previous(true), previous(false)], {
+            const form = await askQuestionnaire(server, service, { ...definitions[0], repoRoot: input.repoRoot }, context, [...definitions, previous(true), previous(false)], {
                 tool: 'worktree.reconcile',
                 ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
                 retryArguments: json({
@@ -671,22 +588,25 @@ export function registerWorktreeTools(server, service) {
                 const missing = item.reasons.includes('worktree directory missing');
                 const questionnaireId = retireQuestionId(item, !missing, input.decisionAttempt);
                 const folder = basename(item.repoRoot);
-                const definition = (turkish) => {
-                    const copy = retireCopy[turkish ? 'tr' : 'en'];
-                    const named = item.branch ?? (turkish ? 'yok' : 'none');
+                const definitions = copies(retireWording, 'retireWorktree', told).map(({ language, copy }) => {
+                    const named = { folder, branch: item.branch ?? copy.noBranch };
                     return {
                         questionnaireId,
-                        language: turkish ? 'tr' : 'en',
+                        language,
                         allowFreeText: false,
-                        message: missing ? copy.missing(folder) : copy.message(folder, named),
-                        context: copy.context(missing),
-                        example: copy.example(folder, named, missing),
+                        message: format(missing ? copy.missing : copy.message, language, named),
+                        context: `${copy.context} ${missing ? copy.contextMissing : copy.contextFolder}`,
+                        example: format(missing ? copy.exampleMissing : copy.example, language, named),
                         options: [
-                            { id: 'retire', label: copy.retire, description: copy.retired(missing) },
+                            {
+                                id: 'retire',
+                                label: copy.retire,
+                                description: missing ? copy.retiredMissing : copy.retired,
+                            },
                             { id: 'keep', label: copy.keep, description: copy.kept },
                         ],
                     };
-                };
+                });
                 const previous = (turkish) => ({
                     questionnaireId,
                     language: turkish ? 'tr' : 'en',
@@ -709,7 +629,7 @@ export function registerWorktreeTools(server, service) {
                         { id: 'keep', label: turkish ? 'Kalsın' : 'Keep it' },
                     ],
                 });
-                const form = await askQuestionnaire(server, service, { ...definition(language === 'tr'), repoRoot: input.repoRoot }, context, [definition(language !== 'tr'), previous(true), previous(false)]);
+                const form = await askQuestionnaire(server, service, { ...definitions[0], repoRoot: input.repoRoot }, context, [...definitions, previous(true), previous(false)]);
                 if (askFailed(form)) {
                     refused.push({
                         repoRoot: item.repoRoot,
@@ -763,21 +683,18 @@ export function registerWorktreeTools(server, service) {
             decisionAttempt: input.decisionAttempt,
         }));
         const questionnaireId = 'worktree-release-unowned-' + digest;
-        const definition = (turkish) => {
-            const copy = unownedCopy[turkish ? 'tr' : 'en'];
-            return {
-                questionnaireId,
-                language: turkish ? 'tr' : 'en',
-                allowFreeText: false,
-                message: copy.message(basename(entry.repoRoot)),
-                context: copy.context,
-                example: copy.example(entry.baseCommit.slice(0, 12)),
-                options: [
-                    { id: 'release_unowned', label: copy.release, description: copy.released },
-                    { id: 'preserve', label: copy.preserve, description: copy.preserved },
-                ],
-            };
-        };
+        const definitions = copies(unownedWording, 'releaseUnowned', told).map(({ language, copy }) => ({
+            questionnaireId,
+            language,
+            allowFreeText: false,
+            message: format(copy.message, language, { folder: basename(entry.repoRoot) }),
+            context: copy.context,
+            example: format(copy.example, language, { commit: entry.baseCommit.slice(0, 12) }),
+            options: [
+                { id: 'release_unowned', label: copy.release, description: copy.released },
+                { id: 'preserve', label: copy.preserve, description: copy.preserved },
+            ],
+        }));
         const previous = (turkish) => ({
             questionnaireId,
             language: turkish ? 'tr' : 'en',
@@ -795,7 +712,7 @@ export function registerWorktreeTools(server, service) {
                 { id: 'preserve', label: turkish ? 'Korumaya devam et' : 'Keep protected' },
             ],
         });
-        const form = await askQuestionnaire(server, service, { ...definition(language === 'tr'), repoRoot: input.repoRoot }, context, [definition(language !== 'tr'), previous(true), previous(false)]);
+        const form = await askQuestionnaire(server, service, { ...definitions[0], repoRoot: input.repoRoot }, context, [...definitions, previous(true), previous(false)]);
         if (askFailed(form))
             return form;
         const decision = await service.questionnaireResume({
@@ -828,7 +745,7 @@ export function registerWorktreeTools(server, service) {
             language: languageTag.optional(),
         }),
     }, async (input, context) => {
-        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
+        const told = await service.language(input.language);
         if (input.deliveryOutcome !== 'cancelled')
             return output(await service.worktreeOperation('release', input));
         const state = await service.worktreeFolder(input);
@@ -841,21 +758,22 @@ export function registerWorktreeTools(server, service) {
                 ...input,
                 decisionId: questionnaireId,
             }));
-        const definition = (turkish) => {
-            const copy = cancelCopy[turkish ? 'tr' : 'en'];
+        const definitions = copies(cancelWording, 'cancelDelivery', told).map(({ language, copy }) => {
             const keep = { id: 'keep', label: copy.keep, description: copy.kept };
             return {
                 questionnaireId,
-                language: turkish ? 'tr' : 'en',
+                language,
                 allowFreeText: false,
-                message: copy.message(input.externalTaskId),
-                context: copy.context(folder.clean, folder.managed),
+                message: format(copy.message, language, { task: input.externalTaskId }),
+                context: folder.clean
+                    ? copy.context
+                    : `${copy.context} ${folder.managed ? copy.uncommittedManaged : copy.uncommittedOwn}`,
                 example: copy.example,
                 options: folder.clean || !folder.managed
                     ? [{ id: 'release', label: copy.release, description: copy.released }, keep]
                     : [{ id: 'save_and_release', label: copy.save, description: copy.saved }, keep],
             };
-        };
+        });
         const previous = (turkish) => ({
             questionnaireId,
             language: turkish ? 'tr' : 'en',
@@ -901,7 +819,7 @@ export function registerWorktreeTools(server, service) {
                     },
                 ],
         });
-        const form = await askQuestionnaire(server, service, { ...definition(language === 'tr'), repoRoot: input.repoRoot }, context, [definition(language !== 'tr'), previous(true), previous(false)]);
+        const form = await askQuestionnaire(server, service, { ...definitions[0], repoRoot: input.repoRoot }, context, [...definitions, previous(true), previous(false)]);
         if (askFailed(form))
             return form;
         const decision = await service.questionnaireResume({