engineering-memory 1.11.9 → 1.11.11

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

@@ -1,10 +1,38 @@
+import { basename } from 'node:path';
 import * as z from 'zod/v4';
-import { branchChoices } from '../runtime/branch-preferences.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';
 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}$/);
+const presentation = z.enum(['host_native']).optional();
+function deferredStart(input, questionnaireId) {
+    return {
+        ok: true,
+        data: json({
+            status: 'deferred',
+            allocated: false,
+            externalTaskId: input.externalTaskId,
+            questionnaireId,
+            reconsider: {
+                tool: 'task.branch',
+                arguments: {
+                    repoRoot: input.repoRoot,
+                    externalTaskId: input.externalTaskId,
+                    decisionAttempt: (input.decisionAttempt ?? 0) + 1,
+                    language: input.language,
+                    name: input.name,
+                    base: input.base,
+                    keepCurrent: input.keepCurrent,
+                },
+            },
+            nextAction: `Nothing was created, reserved or saved. Tell the user in one line that starting ${input.externalTaskId} is on hold. Continue only read-only work. When the user wants to start, call reconsider exactly as given; it asks the start form again.`,
+        }),
+    };
+}
 const output = (r) => ({
     content: [{ type: 'text', text: JSON.stringify(r) }],
     ...(!r.ok ? { isError: true } : {}),
@@ -42,7 +70,7 @@ export function registerWorktreeTools(server, service) {
         }),
     }, async (input) => output(await service.projectGitPreferences(input)));
     server.registerTool('project.set_git_preferences', {
-        description: 'Confirm each supplied shared branch choice with a separate durable native questionnaire, then save against expectedVersion. Explicitly absent production/test branches stay answered. Reconsider a deferred choice with a new decisionAttempt; retries keep the same attempt. Requires project owner/maintainer or organization administrator. Branches are creation preferences, never memory environment labels.',
+        description: 'Confirm every supplied shared branch choice in one durable native questionnaire (one question per role), then save the approved roles against expectedVersion in a single PUT. A role answered "leave unchanged" stays as it was and unanswered. Reconsider with a new decisionAttempt; retries keep the same attempt. Requires project owner/maintainer or organization administrator. Branches are creation preferences, never memory environment labels.',
         inputSchema: z.strictObject({
             repoRoot: repo,
             projectId: z.string().uuid(),
@@ -52,6 +80,7 @@ export function registerWorktreeTools(server, service) {
             production: preference.optional(),
             test: preference.optional(),
             language: z.enum(['tr', 'en']).default('en'),
+            presentation,
         }),
     }, async (input, context) => {
         const current = await service.projectGitPreferences(input);
@@ -68,33 +97,41 @@ export function registerWorktreeTools(server, service) {
                     recovery: 'task.branch',
                 },
             });
-        const changes = { expectedVersion: input.expectedVersion };
-        for (const role of ['development', 'production', 'test']) {
+        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 value = input[role];
-            if (!value)
-                continue;
-            const digest = sha256(stableStringify({
-                projectId: input.projectId,
-                version: input.expectedVersion,
-                role,
-                value,
-                ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
-            }));
-            const question = {
-                repoRoot: input.repoRoot,
-                questionnaireId: 'project-branch-' + digest,
-                message: 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') +
-                        '?',
-                language: input.language,
-                allowFreeText: false,
+            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') +
+                    '?';
+        };
+        const digest = sha256(stableStringify({
+            projectId: input.projectId,
+            version: input.expectedVersion,
+            roles,
+            values: roles.map((role) => input[role]),
+            ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+        }));
+        const questionnaireId = 'project-branches-' + digest;
+        const definition = {
+            repoRoot: input.repoRoot,
+            questionnaireId,
+            presentation: input.presentation,
+            language: input.language,
+            message: input.language === 'tr'
+                ? '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),
                 options: [
                     {
                         id: 'approve',
@@ -105,16 +142,31 @@ export function registerWorktreeTools(server, service) {
                         label: input.language === 'tr' ? 'Şimdilik değiştirme' : 'Leave unchanged',
                     },
                 ],
-            };
-            const form = await askQuestionnaire(server, service, question, context);
-            const record = await service.questionnaireResume({
-                repoRoot: input.repoRoot,
-                questionnaireId: question.questionnaireId,
-            });
-            if (record.status !== 'answered' || record.answer?.choice !== 'approve')
-                return form;
-            changes[role] = json(value);
-        }
+            })),
+        };
+        const owner = {
+            tool: 'project.set_git_preferences',
+            ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+            retryArguments: json({
+                projectId: input.projectId,
+                expectedVersion: input.expectedVersion,
+                development: input.development,
+                production: input.production,
+                test: input.test,
+                language: input.language,
+            }),
+        };
+        const form = await askQuestionnaire(server, service, definition, context, [], owner);
+        const record = await service.questionnaireResume({
+            repoRoot: input.repoRoot,
+            questionnaireId,
+        });
+        if (record.status !== 'answered')
+            return form;
+        const changes = { expectedVersion: input.expectedVersion };
+        for (const role of roles)
+            if (record.answers?.[role]?.choice === 'approve')
+                changes[role] = json(input[role]);
         if (Object.keys(changes).length === 1)
             return output({ ok: true, data: { unchanged: true } });
         return output(await service.setProjectGitPreferences(input.projectId, changes));
@@ -128,7 +180,7 @@ export function registerWorktreeTools(server, service) {
         inputSchema: z.strictObject(policy),
     }, async (input) => output(await service.worktreePolicy(json(input))));
     server.registerTool('task.branch', {
-        description: 'Choose the task base with durable native forms and allocate a separate managed worktree for every new branch. Configured remote branches are fetched and the exact commit is pinned. Retry/resume preserves the allocation. For an explicitly reconsidered deferred answer supply a new decisionAttempt; retries keep the same attempt. Use the returned repoRoot for ALL commands; keepCurrent is allowed only in a free checkout. A read-only task allocates only when transitioning to write.',
+        description: 'Start a write task with ONE durable native form: where the branch starts (unless base is given), the new branch name with a suggested default (unless name is given), and the folder: a separate managed worktree, this folder as a new branch when it is clean (moving out an unfinished task that holds it, named in the option), this folder on its current branch, or not now. Nothing is created until the user answers; the next call with the same arguments allocates. A remote base is fetched and its exact commit pinned. Retry/resume preserves the allocation. Not now returns status deferred with the exact reconsider call; retries keep the same decisionAttempt. Use the returned repoRoot for ALL commands. A read-only task allocates only when transitioning to write.',
         inputSchema: z.strictObject({
             repoRoot: repo,
             externalTaskId: z.string().min(2).max(160),
@@ -137,177 +189,129 @@ export function registerWorktreeTools(server, service) {
             base: baseSchema.optional(),
             keepCurrent: z.boolean().optional(),
             language: z.enum(['tr', 'en']).default('en'),
+            presentation,
         }),
     }, async (input, context) => {
-        const existing = await service.worktreeTaskAllocation(input);
-        if (existing.ok && existing.data.allocation)
+        const preflight = await service.taskBranchPreflight(input);
+        if (!preflight.ok)
+            return output(preflight);
+        const flight = preflight.data;
+        if (flight.existingAllocation)
             return output(await service.taskBranch(input));
-        if (!existing.ok)
-            return output(existing);
-        const current = await service.projectGitPreferences(input);
-        if (!current.ok)
-            return output(current);
-        const prefs = current.data;
-        let base = input.base;
-        let keepCurrent = input.keepCurrent === true;
-        let name = input.name;
-        const taskKey = sha256(input.externalTaskId + (input.decisionAttempt ? ':' + input.decisionAttempt : ''));
-        if (!base && !keepCurrent) {
-            const definition = {
-                repoRoot: input.repoRoot,
-                questionnaireId: 'task-base-select-' + taskKey + '-' + prefs.version,
-                message: input.language === 'tr'
-                    ? 'Bu görev için başlangıç dalını seç.'
-                    : 'Choose the starting branch for this task.',
-                language: input.language,
-                allowFreeText: false,
-                options: branchChoices(prefs, prefs.currentBranch),
-            };
-            const form = await askQuestionnaire(server, service, definition, context);
-            const record = await service.questionnaireResume({
-                repoRoot: input.repoRoot,
-                questionnaireId: definition.questionnaireId,
+        const role = input.base?.kind;
+        if ((role === 'development' || role === 'production' || role === 'test') &&
+            !configuredBase(flight.preferences, role))
+            return output({
+                ok: false,
+                error: {
+                    kind: 'bridge_error',
+                    retryable: false,
+                    message: 'Choose a configured or task-specific base branch.',
+                    recovery: 'task.branch',
+                },
             });
-            if (record.status !== 'answered')
-                return form;
-            const choice = record.answer?.choice;
-            if (choice === 'keep') {
-                keepCurrent = true;
-                base = { kind: 'current' };
-            }
-            else if (choice === 'other') {
-                const next = await askText(server, service, input, context, 'other-base', input.language === 'tr'
-                    ? 'Başlangıç için uzak dalın adını seç. origin remote kullanılacak.'
-                    : 'Choose the remote base branch name. The origin remote will be used.');
-                if (!next.value)
-                    return next.form;
-                base = { kind: 'remote', remote: 'origin', branch: next.value };
-            }
-            else if (choice === 'current' ||
-                choice === 'development' ||
-                choice === 'production' ||
-                choice === 'test')
-                base = { kind: choice };
-            else
-                return form;
-        }
-        if (keepCurrent) {
-            base = { kind: 'current' };
-            name = undefined;
-        }
-        base ??= { kind: 'current' };
-        if (base.kind === 'current')
-            base = { kind: 'current', commit: base.commit ?? prefs.currentCommit ?? undefined };
-        if (base.kind === 'development' || base.kind === 'production' || base.kind === 'test') {
-            const selected = prefs.branches[base.kind];
-            if (!selected.answered || !selected.remote || !selected.branch)
-                return output({
-                    ok: false,
-                    error: {
-                        kind: 'bridge_error',
-                        retryable: false,
-                        message: 'Choose a configured or task-specific base branch.',
-                        recovery: 'task.branch',
-                    },
-                });
-            base = { kind: 'remote', remote: selected.remote, branch: selected.branch };
-        }
-        if (!keepCurrent && !name) {
-            const next = await askText(server, service, input, context, 'branch-name', input.language === 'tr'
-                ? 'Yeni görev branch’inin adı ne olsun?'
-                : 'Name the new task branch.');
-            if (!next.value)
-                return next.form;
-            name = next.value;
-        }
-        const signature = sha256(stableStringify({
+        const definition = taskStartDefinition({ ...input, ...flight });
+        const owner = {
+            tool: 'task.branch',
             externalTaskId: input.externalTaskId,
-            base,
-            name: name ?? null,
-            keepCurrent,
             ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
-        }));
-        const sourceLabel = base.kind === 'remote'
-            ? base.remote + '/' + base.branch
-            : base.kind === 'local'
-                ? base.ref
-                : base.kind === 'current'
-                    ? (prefs.currentBranch ?? 'HEAD')
-                    : prefs.branches[base.kind].remote + '/' + prefs.branches[base.kind].branch;
-        const definition = {
-            repoRoot: input.repoRoot,
-            questionnaireId: 'task-branch-confirm-' + signature,
-            language: input.language,
-            allowFreeText: false,
-            message: input.language === 'tr'
-                ? keepCurrent
-                    ? 'Bu klasörde mevcut branch üzerinde devam edilsin mi?'
-                    : sourceLabel + ' kaynağından ' + name + ' branch’i ayrı worktree’de açılsın mı?'
-                : keepCurrent
-                    ? 'Continue in this checkout on its current branch?'
-                    : 'Create ' + name + ' from ' + sourceLabel + ' in a separate worktree?',
-            options: [
-                { id: 'approve', label: input.language === 'tr' ? 'Devam et' : 'Continue' },
-                { id: 'defer', label: input.language === 'tr' ? 'Şimdilik başlatma' : 'Not now' },
-            ],
+            retryArguments: json({
+                language: input.language,
+                name: input.name,
+                base: input.base,
+                keepCurrent: input.keepCurrent,
+            }),
         };
-        const form = await askQuestionnaire(server, service, definition, context);
+        const form = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot, presentation: input.presentation }, context, [], owner);
         const record = await service.questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId: definition.questionnaireId,
         });
-        if (record.status !== 'answered' || record.answer?.choice !== 'approve')
+        const choice = taskStartChoice(record);
+        if (!choice)
             return form;
-        const fallbackBase = { kind: 'current', commit: prefs.currentCommit ?? undefined };
-        const fallbackSignature = sha256(stableStringify({
+        if (choice.status === 'deferred')
+            return output(deferredStart(input, definition.questionnaireId));
+        const reconsider = (reason) => output({
+            ok: false,
+            error: {
+                kind: 'bridge_error',
+                retryable: false,
+                message: `${reason} Call task.branch with decisionAttempt ${(input.decisionAttempt ?? 0) + 1} to ask the start form again.`,
+                recovery: 'task.branch',
+            },
+        });
+        if (choice.name && choice.name !== input.name && choice.name !== flight.suggestedName) {
+            const unusable = await service.unusableBranchName(input.repoRoot, choice.name);
+            if (unusable)
+                return reconsider(unusable);
+        }
+        const request = {
             externalTaskId: input.externalTaskId,
-            base: fallbackBase,
-            name: name ?? null,
-            keepCurrent,
+            name: choice.name ?? null,
+            keepCurrent: choice.keepCurrent,
             ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
-        }));
-        const fallbackDefinition = {
-            ...definition,
-            questionnaireId: 'task-branch-fallback-' + fallbackSignature,
-            message: input.language === 'tr'
-                ? sourceLabel +
-                    ' uzak dalına ulaşılamadı. Yereldeki ' +
-                    (prefs.currentBranch ?? 'HEAD') +
-                    ' commit’i ' +
-                    (prefs.currentCommit?.slice(0, 12) ?? 'unborn HEAD') +
-                    ' üzerinden ayrı worktree ile devam edilsin mi?'
-                : 'The remote ' +
-                    sourceLabel +
-                    ' is unavailable. Continue from local ' +
-                    (prefs.currentBranch ?? 'HEAD') +
-                    ' commit ' +
-                    (prefs.currentCommit?.slice(0, 12) ?? 'unborn HEAD') +
-                    ' in a separate worktree?',
         };
+        const allocate = (base, decisionId) => service.taskBranch({
+            repoRoot: input.repoRoot,
+            externalTaskId: input.externalTaskId,
+            name: choice.name ?? undefined,
+            keepCurrent: choice.keepCurrent,
+            inPlace: choice.inPlace,
+            base,
+            decisionId,
+            startId: definition.questionnaireId,
+            decisionAttempt: input.decisionAttempt,
+        });
+        const fallbackBase = {
+            kind: 'current',
+            ...(flight.currentCommit ? { commit: flight.currentCommit } : {}),
+        };
+        const fallbackId = 'task-branch-fallback-' +
+            sha256(stableStringify({ ...request, base: fallbackBase, inPlace: choice.inPlace }));
         const fallback = async () => {
-            const form = await askQuestionnaire(server, service, fallbackDefinition, context);
-            const record = await service.questionnaireResume({
+            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,
-                questionnaireId: fallbackDefinition.questionnaireId,
-            });
-            if (record.status !== 'answered' || record.answer?.choice !== 'approve')
-                return form;
-            return output(await service.taskBranch({
+                questionnaireId: fallbackId,
+                language: input.language,
+                presentation: input.presentation,
+                allowFreeText: false,
+                message: tr
+                    ? from +
+                        ' uzak dalına ulaşılamadı. Yereldeki ' +
+                        local +
+                        ' üzerinden ' +
+                        (choice.inPlace ? 'bu klasörde' : 'ayrı worktree ile') +
+                        ' devam edilsin mi?'
+                    : 'The remote ' +
+                        from +
+                        ' is unavailable. Continue from local ' +
+                        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' },
+                ],
+            }, context, [], owner);
+            const answer = await service.questionnaireResume({
                 repoRoot: input.repoRoot,
-                externalTaskId: input.externalTaskId,
-                name,
-                keepCurrent,
-                base: fallbackBase,
-                decisionId: fallbackDefinition.questionnaireId,
-                decisionAttempt: input.decisionAttempt,
-            }));
+                questionnaireId: fallbackId,
+            });
+            if (answer.status === 'answered' && answer.answer?.choice === 'defer')
+                return output(deferredStart(input, fallbackId));
+            if (answer.status !== 'answered' || answer.answer?.choice !== 'approve')
+                return fallbackForm;
+            return output(await allocate(fallbackBase, fallbackId));
         };
-        if (base.kind === 'remote') {
+        if (choice.base.kind === 'remote') {
             let recorded = false;
             try {
                 await service.questionnaireResume({
                     repoRoot: input.repoRoot,
-                    questionnaireId: fallbackDefinition.questionnaireId,
+                    questionnaireId: fallbackId,
                 });
                 recorded = true;
             }
@@ -315,16 +319,8 @@ export function registerWorktreeTools(server, service) {
             if (recorded)
                 return fallback();
         }
-        const attempt = await service.taskBranch({
-            repoRoot: input.repoRoot,
-            externalTaskId: input.externalTaskId,
-            name,
-            keepCurrent,
-            base,
-            decisionId: definition.questionnaireId,
-            decisionAttempt: input.decisionAttempt,
-        });
-        if (base.kind === 'remote' &&
+        const attempt = await allocate(choice.base, definition.questionnaireId);
+        if (choice.base.kind === 'remote' &&
             !attempt.ok &&
             attempt.error?.message.startsWith('The selected remote branch could not be fetched.'))
             return fallback();
@@ -335,24 +331,153 @@ export function registerWorktreeTools(server, service) {
         repoRoot: repo,
         externalTaskId: z.string().min(2).max(160),
         generation: z.string().uuid(),
-        delivered: z.boolean().optional(),
     });
     server.registerTool('worktree.list', {
-        description: 'Discover existing managed Git checkouts and list activity and protection reasons before allocating another folder. Unregistered legacy checkouts remain protected until explicitly reconciled.',
+        description: 'Discover existing managed Git checkouts and list activity and protection reasons before allocating another folder. Unregistered legacy checkouts remain protected until explicitly reconciled. Slots outside the managed root are retired: never reused and not counted toward the limit.',
         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. 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'),
         }),
     }, async (input, context) => {
         const inspection = await service.worktreeOperation('reconcile', input);
-        if (!inspection.ok || !input.releaseUnowned)
+        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 tr = input.language === 'tr';
+            const form = await askQuestionnaire(server, service, {
+                repoRoot: input.repoRoot,
+                questionnaireId,
+                language: input.language,
+                allowFreeText: false,
+                message: tr
+                    ? 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: tr
+                            ? 'Takip etmeyi bırak; dosyalara dokunma'
+                            : 'Stop tracking it; leave the files alone',
+                    },
+                    { id: 'keep', label: tr ? 'Takip etmeye devam et' : 'Keep tracking it' },
+                ],
+            }, context, [], {
+                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 = [];
+            const kept = [];
+            const refused = [];
+            for (const item of items) {
+                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,
+                    questionnaireId,
+                    language: input.language,
+                    allowFreeText: false,
+                    message: input.language === 'tr'
+                        ? folder +
+                            (missing
+                                ? ' eski konumdaki bir worktree kaydı; klasör artık yok. Kaydı silinsin mi?'
+                                : ' eski konumda kalan bir worktree (branch ' +
+                                    (item.branch ?? 'yok') +
+                                    '); artık yeniden kullanılmıyor. Silinsin mi? Branch kalır. Git yalnızca temiz bir klasörü kaldırır ve içindeki .gitignore kapsamındaki dosyaları da siler.')
+                        : folder +
+                            (missing
+                                ? ' is a worktree record in the old location whose folder is gone. Remove the record?'
+                                : ' is a worktree left in the old location (branch ' +
+                                    (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' },
+                    ],
+                }, context);
+                const decision = await service.questionnaireResume({
+                    repoRoot: input.repoRoot,
+                    questionnaireId,
+                });
+                if (decision.status !== 'answered')
+                    return form;
+                if (decision.answer?.choice !== 'retire') {
+                    kept.push(item.repoRoot);
+                    continue;
+                }
+                const result = await service.worktreeOperation('retire', {
+                    repoRoot: input.repoRoot,
+                    worktreePath: item.repoRoot,
+                    generation: item.generation,
+                    decisionId: questionnaireId,
+                });
+                if (result.ok)
+                    retired.push(item.repoRoot);
+                else
+                    refused.push({ repoRoot: item.repoRoot, message: result.error?.message ?? '' });
+            }
+            return output({ ok: true, data: json({ retired, kept, refused }) });
+        }
         const data = inspection.data;
         const entry = data.selected;
         if (!entry?.recoveredWithoutReservation || !entry.baseCommit)
@@ -413,43 +538,77 @@ export function registerWorktreeTools(server, service) {
         inputSchema: ownershipSchema,
     }, async (input) => output(await service.worktreeOperation('heartbeat', input)));
     server.registerTool('task.pause', {
-        description: 'Pause without abandoning or deleting work. Stop writing until session.resume returns the new ownership generation.',
-        inputSchema: ownershipSchema,
+        description: 'Pause without abandoning or deleting work. Stop writing until session.resume returns the new ownership generation. A pause records no delivery; settle delivery with worktree.release.',
+        inputSchema: ownershipSchema.extend({ delivered: z.boolean().optional() }),
     }, async (input) => output(await service.worktreeOperation('pause', input)));
     server.registerTool('worktree.release', {
-        description: 'Safely release this generation only when the checkout is clean and authorized delivery is complete. Never force cleanup.',
-        inputSchema: ownershipSchema,
-    }, async (input) => output(await service.worktreeOperation('release', input)));
-}
-async function askText(server, service, input, context, purpose, message) {
-    const definition = {
-        repoRoot: input.repoRoot,
-        questionnaireId: purpose +
-            '-' +
-            sha256(input.externalTaskId + (input.decisionAttempt ? ':' + input.decisionAttempt : '')),
-        language: input.language,
-        message,
-        allowFreeText: false,
-        options: [
-            { id: 'set', label: input.language === 'tr' ? 'Bu adı kullan' : 'Use this name' },
-            { id: 'defer', label: input.language === 'tr' ? 'Şimdilik başlatma' : 'Not now' },
-        ],
-        textField: {
-            requiredForChoice: 'set',
-            title: input.language === 'tr' ? 'Branch adı' : 'Branch name',
-            maxLength: 255,
-        },
-    };
-    const form = await askQuestionnaire(server, service, definition, context);
-    const record = await service.questionnaireResume({
-        repoRoot: input.repoRoot,
-        questionnaireId: definition.questionnaireId,
+        description: "Release this generation once the user settled its delivery. deliveryOutcome 'delivered' states that authorized delivery happened; 'cancelled' means the user decided not to deliver, and the native question asks whether the folder is kept, released, or its changes saved to a preserved ref before release. A pending delivery needs an outcome. Never force cleanup.",
+        inputSchema: ownershipSchema.extend({
+            deliveryOutcome: z.enum(['delivered', 'cancelled']).optional(),
+            delivered: z.boolean().optional(),
+            language: z.enum(['tr', 'en']).default('en'),
+        }),
+    }, async (input, context) => {
+        if (input.deliveryOutcome !== 'cancelled')
+            return output(await service.worktreeOperation('release', input));
+        const state = await service.worktreeFolder(input);
+        if (!state.ok)
+            return output(state);
+        const folder = state.data;
+        const questionnaireId = cancelledDeliveryQuestionId({ generation: input.generation, managed: folder.managed }, folder.clean);
+        if (!folder.deliveryPending)
+            return output(await service.worktreeOperation('cancel_delivery', {
+                ...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 form = await askQuestionnaire(server, service, {
+            repoRoot: input.repoRoot,
+            questionnaireId,
+            language: input.language,
+            allowFreeText: false,
+            message: input.language === 'tr'
+                ? input.externalTaskId +
+                    ' teslim edilmeyecek. Bu klasör ne olsun?' +
+                    (folder.clean
+                        ? ''
+                        : folder.managed
+                            ? ' Klasörde kaydedilmemiş değişiklikler var; kaydedilirse bir Git ref’inde saklanır ve geri yüklenebilir.'
+                            : ' Klasörde kaydedilmemiş değişiklikler var; bu senin klasörün olduğu için boşaltılsa da dosyalara dokunulmaz.')
+                : input.externalTaskId +
+                    ' will not be delivered. What should happen to this folder?' +
+                    (folder.clean
+                        ? ''
+                        : 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);
+        const decision = await service.questionnaireResume({
+            repoRoot: input.repoRoot,
+            questionnaireId,
+        });
+        if (decision.status !== 'answered')
+            return form;
+        return output(await service.worktreeOperation('cancel_delivery', {
+            ...input,
+            decisionId: questionnaireId,
+        }));
     });
-    return {
-        form,
-        value: record.status === 'answered' && record.answer?.choice === 'set'
-            ? record.answer.text
-            : undefined,
-    };
 }
 //# sourceMappingURL=worktree-tools.js.map