engineering-memory 1.11.10 → 1.11.12

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

@@ -1,9 +1,11 @@
 import { basename } from 'node:path';
 import * as z from 'zod/v4';
-import { cancelledDeliveryQuestionId, } from '../runtime/bridge-service.js';
+import { cancelledDeliveryQuestionId, forgetUnreadableQuestionId, } from '../runtime/bridge-service.js';
 import { configuredBase, sourceLabel, taskStartChoice, taskStartDefinition, } from '../runtime/task-start.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
+import { unreadableWorktree } from '../runtime/worktree-pool.js';
 import { askQuestionnaire } from './questionnaire-tools.js';
+import { languageTag } from '../runtime/questionnaire-store.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}$/);
@@ -48,6 +50,170 @@ 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 baseSchema = z.discriminatedUnion('kind', [
     z.strictObject({
         kind: z.literal('current'),
@@ -78,10 +244,11 @@ export function registerWorktreeTools(server, service) {
             development: preference.optional(),
             production: preference.optional(),
             test: preference.optional(),
-            language: z.enum(['tr', 'en']).default('en'),
+            language: languageTag.optional(),
             presentation,
         }),
     }, async (input, context) => {
+        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
         const current = await service.projectGitPreferences(input);
         if (!current.ok)
             return output(current);
@@ -99,18 +266,9 @@ export function registerWorktreeTools(server, service) {
         const roles = ['development', 'production', 'test'].filter((role) => Boolean(input[role]));
         if (roles.length === 0)
             return output({ ok: true, data: { unchanged: true } });
-        const roleLabel = (role) => {
+        const source = (role, none) => {
             const value = input[role];
-            return input.language === 'tr'
-                ? role +
-                    ' dal tercihi: ' +
-                    (value.branch ? value.remote + '/' + value.branch : 'henüz yok') +
-                    '. Ortak proje ayarını kaydedelim mi?'
-                : 'Save the shared ' +
-                    role +
-                    ' branch preference: ' +
-                    (value.branch ? value.remote + '/' + value.branch : 'none yet') +
-                    '?';
+            return value.branch ? value.remote + '/' + value.branch : none;
         };
         const digest = sha256(stableStringify({
             projectId: input.projectId,
@@ -120,29 +278,44 @@ export function registerWorktreeTools(server, service) {
             ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
         }));
         const questionnaireId = 'project-branches-' + digest;
-        const definition = {
-            repoRoot: input.repoRoot,
+        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) => ({
+                    id: role,
+                    message: copy.ask(copy.roles[role], source(role, null)),
+                    options: [
+                        { id: 'approve', label: copy.save, description: copy.saved },
+                        { id: 'defer', label: copy.leave, description: copy.unchanged },
+                    ],
+                })),
+            };
+        };
+        const previous = (turkish) => ({
             questionnaireId,
-            presentation: input.presentation,
-            language: input.language,
-            message: input.language === 'tr'
+            language: turkish ? 'tr' : 'en',
+            message: turkish
                 ? 'Ortak dal tercihlerini kaydedelim mi? Hiçbir şey kaydedilmeden önce onayını bekliyor.'
                 : 'Save the shared branch preferences? Nothing is saved until you answer.',
             questions: roles.map((role) => ({
                 id: role,
-                message: roleLabel(role),
+                message: turkish
+                    ? role +
+                        ' dal tercihi: ' +
+                        source(role, 'henüz yok') +
+                        '. Ortak proje ayarını kaydedelim mi?'
+                    : 'Save the shared ' + role + ' branch preference: ' + source(role, 'none yet') + '?',
                 options: [
-                    {
-                        id: 'approve',
-                        label: input.language === 'tr' ? 'Bu tercihi kaydet' : 'Save this choice',
-                    },
-                    {
-                        id: 'defer',
-                        label: input.language === 'tr' ? 'Şimdilik değiştirme' : 'Leave unchanged',
-                    },
+                    { id: 'approve', label: turkish ? 'Bu tercihi kaydet' : 'Save this choice' },
+                    { id: 'defer', label: turkish ? 'Şimdilik değiştirme' : 'Leave unchanged' },
                 ],
             })),
-        };
+        });
         const owner = {
             tool: 'project.set_git_preferences',
             ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
@@ -155,7 +328,11 @@ export function registerWorktreeTools(server, service) {
                 language: input.language,
             }),
         };
-        const form = await askQuestionnaire(server, service, definition, context, [], owner);
+        const form = await askQuestionnaire(server, service, {
+            ...definition(language === 'tr'),
+            repoRoot: input.repoRoot,
+            presentation: input.presentation,
+        }, context, [definition(language !== 'tr'), previous(true), previous(false)], owner);
         const record = await service.questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId,
@@ -187,10 +364,11 @@ export function registerWorktreeTools(server, service) {
             name: branch.optional(),
             base: baseSchema.optional(),
             keepCurrent: z.boolean().optional(),
-            language: z.enum(['tr', 'en']).default('en'),
+            language: languageTag.optional(),
             presentation,
         }),
     }, async (input, context) => {
+        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
         const preflight = await service.taskBranchPreflight(input);
         if (!preflight.ok)
             return output(preflight);
@@ -209,7 +387,7 @@ export function registerWorktreeTools(server, service) {
                     recovery: 'task.branch',
                 },
             });
-        const definition = taskStartDefinition({ ...input, ...flight });
+        const { previous, ...definition } = taskStartDefinition({ ...input, ...flight, language });
         const owner = {
             tool: 'task.branch',
             externalTaskId: input.externalTaskId,
@@ -221,7 +399,7 @@ export function registerWorktreeTools(server, service) {
                 keepCurrent: input.keepCurrent,
             }),
         };
-        const form = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot, presentation: input.presentation }, context, [], owner);
+        const form = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot, presentation: input.presentation }, context, [previous], owner);
         const record = await service.questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId: definition.questionnaireId,
@@ -269,16 +447,28 @@ export function registerWorktreeTools(server, service) {
         const fallbackId = 'task-branch-fallback-' +
             sha256(stableStringify({ ...request, base: fallbackBase, inPlace: choice.inPlace }));
         const fallback = async () => {
-            const tr = input.language === 'tr';
             const from = sourceLabel(choice.base, flight.currentBranch);
             const local = sourceLabel(fallbackBase, flight.currentBranch);
-            const fallbackForm = await askQuestionnaire(server, service, {
-                repoRoot: input.repoRoot,
+            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 previousFallback = (turkish) => ({
                 questionnaireId: fallbackId,
-                language: input.language,
-                presentation: input.presentation,
+                language: turkish ? 'tr' : 'en',
                 allowFreeText: false,
-                message: tr
+                message: turkish
                     ? from +
                         ' uzak dalına ulaşılamadı. Yereldeki ' +
                         local +
@@ -291,10 +481,15 @@ export function registerWorktreeTools(server, service) {
                         local +
                         (choice.inPlace ? ' in this folder?' : ' in a separate worktree?'),
                 options: [
-                    { id: 'approve', label: tr ? 'Devam et' : 'Continue' },
-                    { id: 'defer', label: tr ? 'Şimdilik başlatma' : 'Not now' },
+                    { id: 'approve', label: turkish ? 'Devam et' : 'Continue' },
+                    { id: 'defer', label: turkish ? 'Şimdilik başlatma' : 'Not now' },
                 ],
-            }, context, [], owner);
+            });
+            const fallbackForm = await askQuestionnaire(server, service, {
+                ...definition(language === 'tr'),
+                repoRoot: input.repoRoot,
+                presentation: input.presentation,
+            }, context, [definition(language !== 'tr'), previousFallback(true), previousFallback(false)], owner);
             const answer = await service.questionnaireResume({
                 repoRoot: input.repoRoot,
                 questionnaireId: fallbackId,
@@ -336,18 +531,104 @@ export function registerWorktreeTools(server, service) {
         inputSchema: locationSchema,
     }, async (input) => output(await service.worktreeOperation('list', input)));
     server.registerTool('worktree.reconcile', {
-        description: 'Reconcile Git with the local registry, including unregistered legacy checkouts. Use releaseUnowned only on a selected unreserved recovered checkout after prior work has finished; a native source-bound confirmation and fresh safety checks precede reuse. Use retireLegacy only when the user wants old-location slots gone: each retired folder is removed with git worktree remove after its own native approval, and the branch stays. Otherwise never delete files or reset branches.',
+        description: 'Reconcile Git with the local registry, including unregistered legacy checkouts. Use releaseUnowned only on a selected unreserved recovered checkout after prior work has finished; a native source-bound confirmation and fresh safety checks precede reuse. Use retireLegacy only when the user wants old-location slots gone: each retired folder is removed with git worktree remove after its own native approval, and the branch stays. Use forgetUnreadable with the externalTaskId of a checkout that is gone or can no longer be read as a Git worktree, called from a working checkout of the same project: after its own native approval Engineering Memory stops tracking that entry, so it no longer counts toward the limit, and no file in the folder is read, moved or deleted. Otherwise never delete files or reset branches.',
         inputSchema: z.strictObject({
             repoRoot: repo,
             releaseUnowned: z.boolean().optional(),
             retireLegacy: z.boolean().optional(),
+            forgetUnreadable: z.strictObject({ externalTaskId: z.string().min(2).max(160) }).optional(),
             decisionAttempt: z.number().int().min(0).default(0),
-            language: z.enum(['tr', 'en']).default('en'),
+            language: languageTag.optional(),
         }),
     }, async (input, context) => {
+        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
         const inspection = await service.worktreeOperation('reconcile', input);
-        if (!inspection.ok || (!input.releaseUnowned && !input.retireLegacy))
+        if (!inspection.ok ||
+            (!input.releaseUnowned && !input.retireLegacy && !input.forgetUnreadable))
             return output(inspection);
+        if (input.forgetUnreadable) {
+            const item = inspection.data.items.find((entry) => entry.externalTaskId === input.forgetUnreadable.externalTaskId);
+            if (!item || item.activity === 'retired' || !unreadableWorktree(item))
+                return output({
+                    ok: false,
+                    error: {
+                        kind: 'bridge_error',
+                        retryable: false,
+                        recovery: 'worktree.list',
+                        message: 'Only a checkout that is missing or can no longer be read as a Git worktree is forgotten. Call worktree.list to see this task: a readable one is freed with worktree.release, and a retired slot is removed with worktree.reconcile and retireLegacy.',
+                    },
+                });
+            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 previous = (turkish) => ({
+                questionnaireId,
+                language: turkish ? 'tr' : 'en',
+                allowFreeText: false,
+                message: turkish
+                    ? item.externalTaskId +
+                        ' 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ı? Klasördeki hiçbir dosyaya dokunulmaz, hiçbiri silinmez.' +
+                        (item.pendingDelivery
+                            ? ' Bu görev teslimi sonuçlanmadan kapandı; teslim edilmemiş iş varsa yalnızca bu klasörde duruyor.'
+                            : '')
+                    : 'The ' +
+                        folder +
+                        ' folder of task ' +
+                        item.externalTaskId +
+                        ' can no longer be read as a Git checkout. Should Engineering Memory stop tracking it? No file in the folder is touched or deleted.' +
+                        (item.pendingDelivery
+                            ? ' That task closed without its delivery being settled, so any undelivered work exists only in that folder.'
+                            : ''),
+                options: [
+                    {
+                        id: 'forget',
+                        label: turkish
+                            ? 'Takip etmeyi bırak; dosyalara dokunma'
+                            : 'Stop tracking it; leave the files alone',
+                    },
+                    { 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)], {
+                tool: 'worktree.reconcile',
+                ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+                retryArguments: json({
+                    forgetUnreadable: input.forgetUnreadable,
+                    language: input.language,
+                }),
+            });
+            const decision = await service.questionnaireResume({
+                repoRoot: input.repoRoot,
+                questionnaireId,
+            });
+            if (decision.status !== 'answered')
+                return form;
+            if (decision.answer?.choice !== 'forget')
+                return output({ ok: true, data: json({ kept: item.externalTaskId }) });
+            return output(await service.worktreeOperation('forget_unreadable', {
+                repoRoot: input.repoRoot,
+                externalTaskId: item.externalTaskId,
+                generation: item.generation,
+                decisionAttempt: input.decisionAttempt,
+                decisionId: questionnaireId,
+            }));
+        }
         if (input.retireLegacy) {
             const items = inspection.data.items.filter((item) => item.activity === 'retired');
             const retired = [];
@@ -357,12 +638,27 @@ export function registerWorktreeTools(server, service) {
                 const questionnaireId = 'worktree-retire-' + sha256(item.repoRoot + item.generation);
                 const missing = item.reasons.includes('worktree directory missing');
                 const folder = basename(item.repoRoot);
-                const form = await askQuestionnaire(server, service, {
-                    repoRoot: input.repoRoot,
+                const definition = (turkish) => {
+                    const copy = retireCopy[turkish ? 'tr' : 'en'];
+                    const named = item.branch ?? (turkish ? 'yok' : 'none');
+                    return {
+                        questionnaireId,
+                        language: turkish ? 'tr' : 'en',
+                        allowFreeText: false,
+                        message: missing ? copy.missing(folder) : copy.message(folder, named),
+                        context: copy.context(missing),
+                        example: copy.example(folder, named, missing),
+                        options: [
+                            { id: 'retire', label: copy.retire, description: copy.retired(missing) },
+                            { id: 'keep', label: copy.keep, description: copy.kept },
+                        ],
+                    };
+                };
+                const previous = (turkish) => ({
                     questionnaireId,
-                    language: input.language,
+                    language: turkish ? 'tr' : 'en',
                     allowFreeText: false,
-                    message: input.language === 'tr'
+                    message: turkish
                         ? folder +
                             (missing
                                 ? ' eski konumdaki bir worktree kaydı; klasör artık yok. Kaydı silinsin mi?'
@@ -376,13 +672,11 @@ export function registerWorktreeTools(server, service) {
                                     (item.branch ?? 'none') +
                                     '); it is no longer reused. Remove it? The branch stays. Git removes only a clean folder, and its ignored files go with it.'),
                     options: [
-                        {
-                            id: 'retire',
-                            label: input.language === 'tr' ? 'Klasörü kaldır' : 'Remove the folder',
-                        },
-                        { id: 'keep', label: input.language === 'tr' ? 'Kalsın' : 'Keep it' },
+                        { id: 'retire', label: turkish ? 'Klasörü kaldır' : 'Remove the folder' },
+                        { id: 'keep', label: turkish ? 'Kalsın' : 'Keep it' },
                     ],
-                }, context);
+                });
+                const form = await askQuestionnaire(server, service, { ...definition(language === 'tr'), repoRoot: input.repoRoot }, context, [definition(language !== 'tr'), previous(true), previous(false)]);
                 const decision = await service.questionnaireResume({
                     repoRoot: input.repoRoot,
                     questionnaireId,
@@ -426,27 +720,39 @@ export function registerWorktreeTools(server, service) {
             decisionAttempt: input.decisionAttempt,
         }));
         const questionnaireId = 'worktree-release-unowned-' + digest;
-        const form = await askQuestionnaire(server, service, {
-            repoRoot: input.repoRoot,
+        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 previous = (turkish) => ({
             questionnaireId,
-            language: input.language,
+            language: turkish ? 'tr' : 'en',
             allowFreeText: false,
-            message: input.language === 'tr'
+            message: turkish
                 ? 'Bu eski çalışma klasörünün önceki sahiplik kaydı yok. Önceki ajan burada artık çalışmıyor ve teslim tamamlandıysa, temiz klasörü yeniden kullanılabilir yapalım mı? Dosyalar ve branch silinmeyecek.'
                 : 'This legacy checkout has no prior ownership record. If the previous agent has stopped and delivery is complete, make the clean checkout reusable? No files or branches will be deleted.',
             options: [
                 {
                     id: 'release_unowned',
-                    label: input.language === 'tr'
+                    label: turkish
                         ? 'Önceki iş bitti; güvenli kontrollerden sonra kullanılabilir yap'
                         : 'Prior work finished; release after safety checks',
                 },
-                {
-                    id: 'preserve',
-                    label: input.language === 'tr' ? 'Korumaya devam et' : 'Keep protected',
-                },
+                { id: 'preserve', label: turkish ? 'Korumaya devam et' : 'Keep protected' },
             ],
-        }, context);
+        });
+        const form = await askQuestionnaire(server, service, { ...definition(language === 'tr'), repoRoot: input.repoRoot }, context, [definition(language !== 'tr'), previous(true), previous(false)]);
         const decision = await service.questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId,
@@ -474,9 +780,10 @@ export function registerWorktreeTools(server, service) {
         inputSchema: ownershipSchema.extend({
             deliveryOutcome: z.enum(['delivered', 'cancelled']).optional(),
             delivered: z.boolean().optional(),
-            language: z.enum(['tr', 'en']).default('en'),
+            language: languageTag.optional(),
         }),
     }, async (input, context) => {
+        const language = (await service.language(input.language))?.startsWith('tr') ? 'tr' : 'en';
         if (input.deliveryOutcome !== 'cancelled')
             return output(await service.worktreeOperation('release', input));
         const state = await service.worktreeFolder(input);
@@ -489,28 +796,26 @@ export function registerWorktreeTools(server, service) {
                 ...input,
                 decisionId: questionnaireId,
             }));
-        const release = {
-            id: 'release',
-            label: input.language === 'tr'
-                ? 'Klasörü boşalt; branch kalsın'
-                : 'Free the folder; the branch stays',
-        };
-        const save = {
-            id: 'save_and_release',
-            label: input.language === 'tr'
-                ? 'Değişiklikleri kaydedip klasörü boşalt'
-                : 'Save the changes and free the folder',
-        };
-        const keep = {
-            id: 'keep',
-            label: input.language === 'tr' ? 'Klasör olduğu gibi kalsın' : 'Keep the folder as it is',
+        const definition = (turkish) => {
+            const copy = cancelCopy[turkish ? 'tr' : 'en'];
+            const keep = { id: 'keep', label: copy.keep, description: copy.kept };
+            return {
+                questionnaireId,
+                language: turkish ? 'tr' : 'en',
+                allowFreeText: false,
+                message: copy.message(input.externalTaskId),
+                context: copy.context(folder.clean, folder.managed),
+                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 form = await askQuestionnaire(server, service, {
-            repoRoot: input.repoRoot,
+        const previous = (turkish) => ({
             questionnaireId,
-            language: input.language,
+            language: turkish ? 'tr' : 'en',
             allowFreeText: false,
-            message: input.language === 'tr'
+            message: turkish
                 ? input.externalTaskId +
                     ' teslim edilmeyecek. Bu klasör ne olsun?' +
                     (folder.clean
@@ -525,8 +830,33 @@ export function registerWorktreeTools(server, service) {
                         : folder.managed
                             ? ' It has uncommitted changes; saving keeps them in a Git ref they can be restored from.'
                             : ' It has uncommitted changes; this is your own folder, so its files are never touched when it is freed.'),
-            options: folder.clean || !folder.managed ? [release, keep] : [save, keep],
-        }, context);
+            options: folder.clean || !folder.managed
+                ? [
+                    {
+                        id: 'release',
+                        label: turkish
+                            ? 'Klasörü boşalt; branch kalsın'
+                            : 'Free the folder; the branch stays',
+                    },
+                    {
+                        id: 'keep',
+                        label: turkish ? 'Klasör olduğu gibi kalsın' : 'Keep the folder as it is',
+                    },
+                ]
+                : [
+                    {
+                        id: 'save_and_release',
+                        label: turkish
+                            ? 'Değişiklikleri kaydedip klasörü boşalt'
+                            : 'Save the changes and free the folder',
+                    },
+                    {
+                        id: 'keep',
+                        label: turkish ? 'Klasör olduğu gibi kalsın' : 'Keep the folder as it is',
+                    },
+                ],
+        });
+        const form = await askQuestionnaire(server, service, { ...definition(language === 'tr'), repoRoot: input.repoRoot }, context, [definition(language !== 'tr'), previous(true), previous(false)]);
         const decision = await service.questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId,