engineering-memory 1.11.28 → 1.11.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.28",
+  "version": "1.11.29",
   "description": "Installs the Engineering Memory skill and its local MCP bridge. Sign in after installing; your organization and project are resolved from your account.",
   "license": "UNLICENSED",
   "type": "module",

package/runtime/build.json

@@ -1,3 +1,3 @@
 {
-  "gitHead": "7ca14a854db07f8fda3823f303e8a7a6accbebff"
+  "gitHead": "0bcad22013da985e82e5ac61c6fcf0f3bd598fd2"
 }

package/runtime/dist/src/config.js

@@ -71,6 +71,15 @@ export const endpoints = {
     taskDeliveryDeliver: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/delivery/deliver`,
     taskDeliveryCancel: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/delivery/cancel`,
     taskReviewRequest: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/review-request`,
+    reviewQueue: (projectId) => `/projects/${projectId}/reviews`,
+    review: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/review`,
+    reviewRounds: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/review/rounds`,
+    reviewRoundResult: (projectId, roundId) => `/projects/${projectId}/review-rounds/${roundId}/result`,
+    reviewRoundRules: (projectId, roundId) => `/projects/${projectId}/review-rounds/${roundId}/rules`,
+    reviewFindingRejection: (projectId, findingId) => `/projects/${projectId}/review-findings/${findingId}/rejection`,
+    reviewPass: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/review/pass`,
+    reviewSkip: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/review/skip`,
+    reviewExemption: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/review/exemption`,
     projectSetup: '/projects/setup',
     projectList: '/projects',
     projectResolve: '/projects/resolve',

package/runtime/dist/src/git/git-inspector.js

@@ -429,6 +429,19 @@ export class GitInspector {
         const result = await this.runner.run('git', ['merge-base', '--is-ancestor', ancestor, descendant], { cwd: repoRoot });
         return result.exitCode === 0;
     }
+    async mergeBase(repoRoot, left, right) {
+        return await this.gitValue(repoRoot, ['merge-base', left, right]);
+    }
+    async changedFiles(repoRoot, base, head) {
+        const result = await this.runner.run('git', ['diff', '--name-status', '-z', '--no-renames', base, head, '--'], { cwd: repoRoot });
+        if (result.exitCode !== 0)
+            throw new Error(`Git diff failed: ${result.stderr.trim()}`);
+        const tokens = result.stdout.split('\0').filter(Boolean);
+        const files = [];
+        for (let index = 0; index + 1 < tokens.length; index += 2)
+            files.push({ status: tokens[index], path: normalizeGitPath(tokens[index + 1]) });
+        return files;
+    }
     async remoteRefContaining(repoRoot, commit) {
         return await this.gitValue(repoRoot, [
             'for-each-ref',

package/runtime/dist/src/localization/catalogue.generated.js

@@ -35,6 +35,10 @@ export const bundledTexts = {
         'delivery.commit_push_draft_pr.label': 'Commit, push and draft PR/MR',
         'delivery.commit_push_pr.description': 'Push the branch and open a request ready for review.',
         'delivery.commit_push_pr.label': 'Commit, push and PR/MR',
+        'delivery.commit_push_pr_unreviewed.description': 'The PR/MR opens ready for the team; no code review is recorded.',
+        'delivery.commit_push_pr_unreviewed.label': 'Commit, push and PR/MR without review',
+        'delivery.commit_push_review_pr.description': 'The PR/MR opens as a draft and becomes ready once the code review ends.',
+        'delivery.commit_push_review_pr.label': 'Commit, push and PR/MR, reviewed first',
         'delivery.context': 'The task is verified and closed. This choice determines where the code goes; approval to publish memory does not authorize Git delivery.',
         'delivery.defer.description': 'Keep the task closed and preserve its files without Git delivery.',
         'delivery.defer.label': 'Keep it for now',
@@ -42,6 +46,9 @@ export const bundledTexts = {
         'delivery.example': 'Commit keeps work on the local branch. PR/MR pushes that branch and opens it for team review.',
         'delivery.message': 'How should we deliver these changes?',
         'delivery.recorded': 'Already answered in Engineering Memory',
+        'delivery.reviewFix': 'These changes fix the review findings of {task}, so they go onto its open PR/MR branch; no new PR/MR is opened.',
+        'delivery.reviewOptional': 'Code review is optional in this project: choose a reviewed PR/MR or one without review.',
+        'delivery.reviewRequired': 'This project reviews code before a PR/MR is ready: the PR/MR opens as a draft and becomes ready after the review.',
         'forgetWorktree.context': '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.',
         'forgetWorktree.example': 'After this, {task} no longer appears in the worktree list and the {folder} folder stays on disk exactly as it is.',
         'forgetWorktree.forget': 'Stop tracking it; leave the files alone',
@@ -263,6 +270,38 @@ export const bundledTexts = {
         'reviewBatch.untitled': 'untitled {kind}',
         'reviewBatch.unversioned': 'Written without a source inspection: {titles}. Tasks that read memory by source version will not see them until an inspection retains them.',
         'reviewBatch.why': 'Why',
+        'reviewConclude.confirm.description': 'The review ends as described above.',
+        'reviewConclude.confirm.label': 'Yes, end it',
+        'reviewConclude.defer.description': 'The review stays open; nothing is recorded.',
+        'reviewConclude.defer.label': 'Not now',
+        'reviewConclude.example': 'After this, the PR/MR can be made ready for the team.',
+        'reviewConclude.exempted.context': 'Review is required here, so only an owner or maintainer can exempt a delivery, with a written reason that stays with the review.',
+        'reviewConclude.exempted.message': 'Exempt {task} from review?',
+        'reviewConclude.passed.context': 'The fix was pushed and no finding is open. Without a new round, the last round’s result stands.',
+        'reviewConclude.passed.message': 'End the review of {task} as passed?',
+        'reviewConclude.reasonTitle': 'Reason',
+        'reviewConclude.skipped.context': 'Code review is not required in this project, so it can be skipped. Engineering Memory records that it was skipped and by whom.',
+        'reviewConclude.skipped.message': 'Skip the review of {task}?',
+        'reviewPolicy.context': 'The setting applies to the whole project from now on; work already delivered keeps its review state. On GitHub, Engineering Memory records the setting but GitHub does not enforce it.',
+        'reviewPolicy.current': 'Current setting',
+        'reviewPolicy.example': 'With Required, a finished task’s PR/MR opens as a draft, an agent reviews it against the project’s rules, and it becomes ready once each finding is fixed or rejected with a reason.',
+        'reviewPolicy.keep.description': 'Nothing changes.',
+        'reviewPolicy.keep.label': 'Leave it as it is',
+        'reviewPolicy.message': 'Should code be reviewed before a PR/MR is ready?',
+        'reviewPolicy.none.description': 'Deliveries work as they do today, with no code review step.',
+        'reviewPolicy.none.label': 'No review',
+        'reviewPolicy.optional.description': 'The delivery question offers a reviewed PR/MR or one without review; a review can be skipped at any time.',
+        'reviewPolicy.optional.label': 'Optional',
+        'reviewPolicy.required.description': 'Every PR/MR is reviewed before it is ready; only an owner or maintainer can exempt one, with a written reason.',
+        'reviewPolicy.required.label': 'Required',
+        'reviewReject.context': 'A rejected finding needs a written reason. The reason stays with the review, where the team sees it.',
+        'reviewReject.example': 'For example: “This rule is for screens, and this file is a test helper.”',
+        'reviewReject.keep.description': 'The finding stays open.',
+        'reviewReject.keep.label': 'Keep the finding',
+        'reviewReject.message': 'Reject this review finding?',
+        'reviewReject.reasonTitle': 'Reason',
+        'reviewReject.reject.description': 'The finding no longer holds the review back.',
+        'reviewReject.reject.label': 'Reject with this reason',
         'reworkPlan.approve.description': 'The work items are created now, exactly as listed. Implementing each phase still starts separately.',
         'reworkPlan.approve.label': 'Create these work items',
         'reworkPlan.branch': 'branch',
@@ -357,6 +396,7 @@ export const bundledTexts = {
         'taskStart.base.other': 'Another branch on origin',
         'taskStart.base.otherDetail': 'Enter it below.',
         'taskStart.continuePlan': "Continue {branch}, the branch of this work item's confirmed plan",
+        'taskStart.continueReview': 'Continue {branch}, the branch of the PR/MR of {task} under review',
         'taskStart.example': 'A worktree keeps this task in its own folder.',
         'taskStart.keepContext': 'Continue on the current branch.',
         'taskStart.location.busy': 'Task {task} is still running in another client in this folder, so the new branch cannot start here. Once it is paused there, this folder can be chosen too.',
@@ -461,6 +501,10 @@ export const bundledTexts = {
         'delivery.commit_push_draft_pr.label': 'Commit, push ve taslak PR/MR',
         'delivery.commit_push_pr.description': 'Dalı gönder ve incelemeye hazır bir istek aç.',
         'delivery.commit_push_pr.label': 'Commit, push ve PR/MR',
+        'delivery.commit_push_pr_unreviewed.description': 'PR/MR ekibe hazır açılır; kod incelemesi kaydedilmez.',
+        'delivery.commit_push_pr_unreviewed.label': 'Commit, push ve incelemesiz PR/MR',
+        'delivery.commit_push_review_pr.description': 'PR/MR taslak açılır; kod incelemesi bitince hazıra alınır.',
+        'delivery.commit_push_review_pr.label': 'Commit, push ve PR/MR (önce incelenir)',
         'delivery.context': 'Görev doğrulandı ve kapandı. Bu seçim kodun nereye gönderileceğini belirler; hafıza değişikliklerini yayımlama onayı bunun yerine geçmez.',
         'delivery.defer.description': 'Görev kapalı kalır; dosyalar korunur, Git teslimi yapılmaz.',
         'delivery.defer.label': 'Şimdilik beklet',
@@ -468,6 +512,9 @@ export const bundledTexts = {
         'delivery.example': 'Commit yerel dalda kalır. PR/MR seçersen değişiklikler uzak dala gönderilir ve ekip incelemesine açılır.',
         'delivery.message': 'Değişiklikleri nasıl teslim edelim?',
         'delivery.recorded': 'Engineering Memory’de verilmiş cevap',
+        'delivery.reviewFix': 'Bu değişiklikler {task} incelemesindeki bulguları düzeltir; açık PR/MR dalına gider, yeni PR/MR açılmaz.',
+        'delivery.reviewOptional': 'Bu projede kod incelemesi isteğe bağlı: incelenen ya da incelemesiz bir PR/MR seçebilirsin.',
+        'delivery.reviewRequired': 'Bu projede PR/MR hazır olmadan önce kod incelenir: PR/MR taslak açılır, inceleme bitince hazıra alınır.',
         'forgetWorktree.context': '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.',
         'forgetWorktree.example': 'Bundan sonra {task} worktree listesinde görünmez, {folder} klasörü ise diskte olduğu gibi kalır.',
         'forgetWorktree.forget': 'Takip etmeyi bırak; dosyalara dokunma',
@@ -689,6 +736,38 @@ export const bundledTexts = {
         'reviewBatch.untitled': 'başlıksız {kind}',
         'reviewBatch.unversioned': 'Kaynak incelemesi yapılmadan yazılanlar: {titles}. Hafızayı kaynak sürümüne göre okuyan görevler, bir inceleme bunları saklayana kadar görmez.',
         'reviewBatch.why': 'Nedeni',
+        'reviewConclude.confirm.description': 'İnceleme yukarıda anlatıldığı gibi sonuçlanır.',
+        'reviewConclude.confirm.label': 'Evet, bitir',
+        'reviewConclude.defer.description': 'İnceleme açık kalır; hiçbir şey kaydedilmez.',
+        'reviewConclude.defer.label': 'Şimdi değil',
+        'reviewConclude.example': 'Bundan sonra PR/MR ekip için hazıra alınabilir.',
+        'reviewConclude.exempted.context': 'Burada inceleme zorunlu; bu yüzden yalnızca sahip ya da bakımcı, incelemeyle birlikte kalacak yazılı bir gerekçeyle muaf tutabilir.',
+        'reviewConclude.exempted.message': '{task} incelemeden muaf tutulsun mu?',
+        'reviewConclude.passed.context': 'Düzeltme gönderildi ve açık bulgu yok. Yeni tur yapılmazsa son turun sonucu geçerli olur.',
+        'reviewConclude.passed.message': '{task} incelemesi geçti olarak bitsin mi?',
+        'reviewConclude.reasonTitle': 'Gerekçe',
+        'reviewConclude.skipped.context': 'Bu projede kod incelemesi zorunlu değil, atlanabilir. Engineering Memory atlandığını ve kimin atladığını kaydeder.',
+        'reviewConclude.skipped.message': '{task} incelemesi atlansın mı?',
+        'reviewPolicy.context': 'Ayar bundan sonra tüm projede geçerli olur; önceden teslim edilen işlerin inceleme durumu değişmez. GitHub’da ayarı Engineering Memory kaydeder, GitHub zorlamaz.',
+        'reviewPolicy.current': 'Şu anki ayar',
+        'reviewPolicy.example': 'Zorunlu seçilirse biten görevin PR/MR’ı taslak açılır, bir ajan projenin kurallarına göre inceler; her bulgu düzeltilince ya da gerekçeyle reddedilince hazıra alınır.',
+        'reviewPolicy.keep.description': 'Hiçbir şey değişmez.',
+        'reviewPolicy.keep.label': 'Olduğu gibi kalsın',
+        'reviewPolicy.message': 'PR/MR hazır olmadan önce kod incelensin mi?',
+        'reviewPolicy.none.description': 'Teslimler bugünkü gibi olur; kod incelemesi adımı yoktur.',
+        'reviewPolicy.none.label': 'İnceleme yok',
+        'reviewPolicy.optional.description': 'Teslim sorusu incelenen ya da incelemesiz PR/MR sunar; inceleme her an atlanabilir.',
+        'reviewPolicy.optional.label': 'İsteğe bağlı',
+        'reviewPolicy.required.description': 'Her PR/MR hazır olmadan önce incelenir; yalnızca sahip ya da bakımcı yazılı gerekçeyle muaf tutabilir.',
+        'reviewPolicy.required.label': 'Zorunlu',
+        'reviewReject.context': 'Reddedilen bulgu için yazılı gerekçe gerekir. Gerekçe incelemeyle birlikte kalır ve ekip görür.',
+        'reviewReject.example': 'Örneğin: “Bu kural ekranlar için; bu dosya bir test yardımcısı.”',
+        'reviewReject.keep.description': 'Bulgu açık kalır.',
+        'reviewReject.keep.label': 'Bulgu kalsın',
+        'reviewReject.message': 'Bu inceleme bulgusu reddedilsin mi?',
+        'reviewReject.reasonTitle': 'Gerekçe',
+        'reviewReject.reject.description': 'Bulgu artık incelemeyi bekletmez.',
+        'reviewReject.reject.label': 'Bu gerekçeyle reddet',
         'reworkPlan.approve.description': 'İş kalemleri listelendiği gibi şimdi oluşturulur. Aşamaların kodlanması yine ayrı ayrı başlar.',
         'reworkPlan.approve.label': 'Bu iş kalemlerini oluştur',
         'reworkPlan.branch': 'dal',
@@ -783,6 +862,7 @@ export const bundledTexts = {
         'taskStart.base.other': 'origin üzerinde başka dal',
         'taskStart.base.otherDetail': 'Alttaki alana yaz.',
         'taskStart.continuePlan': '{branch} dalında devam: bu iş kaleminin onaylı planındaki dal',
+        'taskStart.continueReview': '{branch} dalında devam: {task} için incelenen PR/MR’ın dalı',
         'taskStart.example': 'Ayrı worktree, işi ayrı klasörde tutar.',
         'taskStart.keepContext': 'Mevcut dalda devam edilecek.',
         'taskStart.location.busy': '{task} bu klasörde başka bir oturumda hâlâ çalışıyor; yeni branch burada açılamaz. O oturumda duraklatılırsa bu klasör de seçilebilir.',

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

@@ -7,6 +7,7 @@ const option = z.strictObject({
     label: z.string().trim().min(1).max(100),
     description: z.string().trim().min(1).max(240),
 });
+const reviewLine = z.string().trim().min(1).max(300);
 const copySchema = z.strictObject({
     message: z.string().trim().min(1).max(240),
     context: z.string().trim().min(1).max(500),
@@ -17,12 +18,26 @@ const copySchema = z.strictObject({
     commit_push_draft_pr: option,
     commit_push_pr: option,
     defer: option,
+    commit_push_review_pr: option.optional(),
+    commit_push_pr_unreviewed: option.optional(),
+    reviewRequired: reviewLine.optional(),
+    reviewOptional: reviewLine.optional(),
+    reviewFix: reviewLine.optional(),
     baseMessage: z.string().trim().min(1).max(240),
     baseContext: z.string().trim().min(1).max(500),
     baseTitle: z.string().trim().min(1).max(100),
     baseWrite: option,
     recorded: z.string().trim().min(1).max(100).optional(),
 });
+const deliveryChoices = [
+    'commit',
+    'commit_push',
+    'commit_push_review_pr',
+    'commit_push_draft_pr',
+    'commit_push_pr',
+    'defer',
+];
+const reviewPolicy = z.enum(['none', 'optional', 'required']);
 const closedSchema = z.object({
     closed: z.literal(true),
     taskVersion: z.number().int().positive(),
@@ -47,8 +62,11 @@ const closedSchema = z.object({
         taskId: z.string(),
         lockVersion: z.number().int(),
         choice: z.enum(['commit', 'commit_push', 'commit_push_draft_pr', 'commit_push_pr']).nullish(),
+        reviewState: z.string().nullish(),
     })
         .nullish(),
+    reviewPolicy: reviewPolicy.optional(),
+    reviewFixOf: z.object({ taskId: z.string(), externalTaskId: z.string() }).nullish(),
 });
 const recordWording = z.strictObject({
     message: z.string().trim().min(1).max(240),
@@ -63,7 +81,48 @@ const recordSchema = z.object({
     branch: z.string().nullable(),
     state: z.enum(['unanswered', 'answered', 'delivered', 'cancelled']),
     lockVersion: z.number().int(),
+    reviewPolicy: reviewPolicy.optional(),
+    reviewFixOfDeliveryId: z.string().nullish(),
 });
+function offered(policy, fix) {
+    if (fix)
+        return ['commit', 'commit_push'];
+    if (policy === 'required')
+        return ['commit', 'commit_push', 'commit_push_review_pr'];
+    if (policy === 'optional')
+        return ['commit', 'commit_push', 'commit_push_review_pr', 'commit_push_pr'];
+    return ['commit', 'commit_push', 'commit_push_draft_pr', 'commit_push_pr'];
+}
+function wording(copy, policy, choice) {
+    return choice === 'commit_push_pr' && policy === 'optional'
+        ? copy.commit_push_pr_unreviewed
+        : copy[choice];
+}
+function pullRequest(choice) {
+    return (choice === 'commit_push_review_pr' ||
+        choice === 'commit_push_draft_pr' ||
+        choice === 'commit_push_pr');
+}
+const incompleteCopy = {
+    ok: false,
+    error: {
+        kind: 'delivery',
+        message: "Supply complete delivery copy in the conversation language before closing, including the code review wording this project's question needs (commit_push_review_pr, commit_push_pr_unreviewed, reviewRequired, reviewOptional, reviewFix).",
+        recovery: 'task.close',
+        retryable: false,
+    },
+};
+function settingChanged(tool, now) {
+    return output({
+        ok: false,
+        error: {
+            kind: 'delivery',
+            message: `The project's code review setting changed to ${now} while the delivery question was open, so the answer was not recorded and no Git action was performed. Tell the user, then call ${tool} again: its question follows the new setting.`,
+            recovery: tool,
+            retryable: true,
+        },
+    });
+}
 export function registerDeliveryTools(server, service) {
     registerTaskDelivery(server, service);
     registerTaskReviewRequest(server, service);
@@ -79,13 +138,7 @@ export function registerDeliveryTools(server, service) {
             decisionAttempt: z.number().int().min(1).max(10000).optional(),
             deliveryInstruction: z
                 .strictObject({
-                choice: z.enum([
-                    'commit',
-                    'commit_push',
-                    'commit_push_draft_pr',
-                    'commit_push_pr',
-                    'defer',
-                ]),
+                choice: z.enum(deliveryChoices),
                 userRequestExcerpt: z.string().trim().min(1).max(1200),
                 baseBranch: z.string().trim().min(1).max(240).optional(),
             })
@@ -123,6 +176,8 @@ export function registerDeliveryTools(server, service) {
         const data = parsed.data;
         if (data.deliveryContext.mode === 'read_only')
             return output(closed);
+        const policy = data.reviewPolicy ?? 'none';
+        const fix = data.reviewFixOf ?? null;
         const delivered = data.delivery.alreadyDelivered;
         if (delivered)
             return output({
@@ -130,7 +185,12 @@ export function registerDeliveryTools(server, service) {
                 data: {
                     ...closed.data,
                     deliveryStatus: 'delivered',
-                    nextAction: `Everything this task changed was already committed and pushed by hand: ${delivered.ref.replace(/^refs\/remotes\//, '')} contains ${delivered.commit.slice(0, 12)}. There is nothing left to deliver, so no delivery question is asked, and the delivery is recorded for the project. Call worktree.release in this folder with deliveryOutcome delivered to settle the folder.`,
+                    nextAction: `Everything this task changed was already committed and pushed by hand: ${delivered.ref.replace(/^refs\/remotes\//, '')} contains ${delivered.commit.slice(0, 12)}. There is nothing left to deliver, so no delivery question is asked, and the delivery is recorded for the project. Call worktree.release in this folder with deliveryOutcome delivered to settle the folder.` +
+                        (fix
+                            ? ` This task fixes the review findings of ${fix.externalTaskId}: once the push is recorded, its open findings are marked fixed at this commit. Read review.get for ${fix.externalTaskId} and ask the user whether to review it again (review.start) or end its review as passed (review.conclude).`
+                            : policy === 'required'
+                                ? ' Code review is required in this project: if a PR/MR is opened for this branch, open it as a draft and record it (task.open_review_request on GitLab, task.review_request elsewhere). Recording it starts the review, which review.start runs.'
+                                : ''),
                 },
             });
         const destination = data.delivery.destination;
@@ -152,6 +212,8 @@ export function registerDeliveryTools(server, service) {
             language,
             copy,
             decisionAttempt: input.decisionAttempt ?? 0,
+            reviewPolicy: policy,
+            reviewFixOf: fix?.taskId ?? null,
         };
         const binding = { deliveryDigest: sha256(stableStringify(identity)) };
         const owner = {
@@ -163,20 +225,47 @@ export function registerDeliveryTools(server, service) {
         const questionnaireId = 'task-delivery-' + binding.deliveryDigest;
         const canPush = Boolean(destination.remote && destination.pushUrl);
         const ids = canPush
-            ? ['commit', 'commit_push', 'commit_push_draft_pr', 'commit_push_pr', 'defer']
+            ? [...offered(policy, Boolean(fix)), 'defer']
             : ['commit', 'defer'];
         const instruction = input.deliveryInstruction;
-        const recorded = data.deliveryRecord?.choice;
-        if (instruction && !ids.some((id) => id === instruction.choice))
+        const instructed = !instruction
+            ? null
+            : fix && pullRequest(instruction.choice)
+                ? 'commit_push'
+                : policy === 'required' && pullRequest(instruction.choice)
+                    ? 'commit_push_review_pr'
+                    : instruction.choice;
+        if (instructed && !ids.includes(instructed))
             return output({
                 ok: false,
                 error: {
                     kind: 'delivery',
-                    message: 'This delivery needs an available remote and push URL. No Git action was performed.',
+                    message: !canPush
+                        ? 'This delivery needs an available remote and push URL. No Git action was performed.'
+                        : policy === 'none'
+                            ? 'Code review is off in this project, so a reviewed PR/MR is not offered. No Git action was performed. Call task.close without deliveryInstruction to ask the user how to deliver.'
+                            : 'Code review is optional in this project, so a draft PR/MR is either reviewed first or opened without review, and the instruction does not say which. No Git action was performed. Call task.close without deliveryInstruction to ask the user.',
                     recovery: 'task.close',
                     retryable: false,
                 },
             });
+        const line = !canPush
+            ? ''
+            : fix
+                ? copy.reviewFix && format(copy.reviewFix, language ?? 'en', { task: fix.externalTaskId })
+                : policy === 'required'
+                    ? copy.reviewRequired
+                    : policy === 'optional'
+                        ? copy.reviewOptional
+                        : '';
+        if (!instruction && (line === undefined || ids.some((id) => !wording(copy, policy, id))))
+            return output(incompleteCopy);
+        const recorded = data.deliveryRecord?.choice;
+        const recordedLabel = !recorded
+            ? undefined
+            : data.deliveryRecord?.reviewState === 'pending'
+                ? (copy.commit_push_review_pr ?? copy[recorded]).label
+                : (wording(copy, policy, recorded) ?? copy[recorded]).label;
         const form = instruction
             ? null
             : await askQuestionnaire(server, service, {
@@ -192,18 +281,15 @@ export function registerDeliveryTools(server, service) {
                     ': ' +
                     destination.branch +
                     (canPush ? ' → ' + destination.remote + ' (' + destination.pushUrl + ')' : '') +
-                    (recorded && copy.recorded
-                        ? '\n' + copy.recorded + ': ' + copy[recorded].label
-                        : ''),
+                    (recordedLabel && copy.recorded
+                        ? '\n' + copy.recorded + ': ' + recordedLabel
+                        : '') +
+                    (line ? '\n' + line : ''),
                 example: copy.example,
-                options: ids.map((id) => ({
-                    id,
-                    label: copy[id].label,
-                    description: copy[id].description,
-                })),
+                options: ids.map((id) => ({ id, ...wording(copy, policy, id) })),
                 binding,
             }, context, [], owner);
-        const choice = instruction?.choice ?? (form ? answerChoice(form) : null);
+        const choice = instructed ?? (form ? answerChoice(form) : null);
         if (!choice)
             return form;
         const { deliveryInstruction: _instruction, ...formInput } = input;
@@ -227,11 +313,9 @@ export function registerDeliveryTools(server, service) {
             return deferred();
         service.live.deliveryStarted();
         try {
-            let baseBranch = choice === 'commit_push_draft_pr' || choice === 'commit_push_pr'
-                ? instruction?.baseBranch
-                : undefined;
+            let baseBranch = pullRequest(choice) ? instruction?.baseBranch : undefined;
             let baseQuestionnaireId;
-            if ((choice === 'commit_push_draft_pr' || choice === 'commit_push_pr') && !baseBranch) {
+            if (pullRequest(choice) && !baseBranch) {
                 baseQuestionnaireId = 'task-delivery-base-' + sha256(questionnaireId + choice);
                 const base = await askPullRequestBase(server, service, context, { ...input, questionnaireId: baseQuestionnaireId, binding: { ...binding, choice } }, language, copy, owner);
                 if (!answerChoice(base))
@@ -242,7 +326,7 @@ export function registerDeliveryTools(server, service) {
                 if (!baseBranch)
                     return base;
             }
-            if (choice === 'commit_push_draft_pr' || choice === 'commit_push_pr') {
+            if (pullRequest(choice)) {
                 const valid = await service.taskDeliveryBase({
                     repoRoot: input.repoRoot,
                     branch: baseBranch,
@@ -299,6 +383,9 @@ export function registerDeliveryTools(server, service) {
                         retryable: false,
                     },
                 });
+            const now = current.data.reviewPolicy ?? 'none';
+            if (pullRequest(choice) && now !== policy)
+                return settingChanged('task.close', now);
             const question = instruction
                 ? null
                 : await service.questionnaireResume({ repoRoot: input.repoRoot, questionnaireId });
@@ -313,14 +400,21 @@ export function registerDeliveryTools(server, service) {
                     projectId: record.projectId,
                     taskId: record.taskId,
                     expectedVersion: record.lockVersion,
-                    choice,
+                    choice: choice === 'commit_push_review_pr' ? 'commit_push_draft_pr' : choice,
                     ...(baseBranch ? { baseBranch } : {}),
+                    ...(pullRequest(choice) && data.reviewPolicy
+                        ? { expectedReviewPolicy: data.reviewPolicy }
+                        : {}),
                     answerSource: question ? answerSourceName(question.answerSource) : 'user_instruction',
                 })
                 : null;
             const answered = answer?.ok ? answer.data : null;
             const refused = answer && !answer.ok ? answer.error : null;
-            const other = refused?.details?.delivery;
+            const details = refused?.details;
+            if (details?.reviewPolicy)
+                return settingChanged('task.close', details.reviewPolicy);
+            const other = details?.delivery;
+            const told = instruction && instructed !== instruction.choice ? instruction.choice : null;
             return output({
                 ok: true,
                 data: {
@@ -352,7 +446,24 @@ export function registerDeliveryTools(server, service) {
                         ...(baseQuestionnaireId ? { baseQuestionnaireId } : {}),
                         destination,
                     },
-                    nextAction: 'Perform only the selected Git delivery under host permissions. No commit, push, PR/MR or merge was executed by task.close. Preserve this exact branch and destination.',
+                    nextAction: [
+                        'Perform only the selected Git delivery under host permissions. No commit, push, PR/MR or merge was executed by task.close. Preserve this exact branch and destination.',
+                        told && fix
+                            ? `The user asked for a PR/MR, but this task fixes the review findings of ${fix.externalTaskId}, whose PR/MR is already open: its changes are committed and pushed onto that branch and no new PR/MR is opened. Tell the user.`
+                            : told
+                                ? 'The user asked for a PR/MR without saying it is reviewed, and code review is required in this project, so it opens as a draft and becomes ready once the review ends. Tell the user.'
+                                : '',
+                        choice === 'commit_push_review_pr'
+                            ? `After the push and worktree.release, open the PR/MR into ${baseBranch} as a draft: on GitLab task.open_review_request opens it as a draft; elsewhere open it as a draft with your own tools and record it with task.review_request. Then start the code review with review.start for this task. The PR/MR becomes ready when the review ends.`
+                            : '',
+                        fix && choice === 'commit_push'
+                            ? `The push goes onto ${destination.branch}, the open PR/MR branch of ${fix.externalTaskId}; open no new PR/MR. Once the push is recorded by worktree.release, the open findings of ${fix.externalTaskId} are marked fixed at that commit: read review.get for ${fix.externalTaskId} and ask the user whether to review it again (review.start) or end its review as passed (review.conclude).`
+                            : fix
+                                ? `The findings of ${fix.externalTaskId} stay open until this commit is pushed onto its PR/MR branch.`
+                                : '',
+                    ]
+                        .filter(Boolean)
+                        .join(' '),
                 },
             });
         }
@@ -375,10 +486,10 @@ function registerTaskDelivery(server, service) {
     }, async (input, context) => {
         const language = await service.language(input.language);
         const copy = language ? copySchema.safeParse(texts('delivery', language)).data : undefined;
-        const wording = language
+        const recordCopy = language
             ? recordWording.safeParse(texts('taskDelivery', language)).data
             : undefined;
-        if (!language || !copy || !wording)
+        if (!language || !copy || !recordCopy)
             return output({
                 ok: false,
                 error: {
@@ -410,7 +521,14 @@ function registerTaskDelivery(server, service) {
                     nextAction: 'This delivery is already concluded. Tell the user what was recorded.',
                 },
             });
-        const binding = { taskId: record.taskId, lockVersion: record.lockVersion };
+        const policy = record.reviewPolicy ?? 'none';
+        const fix = Boolean(record.reviewFixOfDeliveryId);
+        const binding = {
+            taskId: record.taskId,
+            lockVersion: record.lockVersion,
+            reviewPolicy: policy,
+            reviewFix: fix,
+        };
         const questionnaireId = 'task-delivery-record-' +
             sha256(stableStringify({ ...binding, decisionAttempt: input.decisionAttempt ?? 0 }));
         const owner = {
@@ -423,28 +541,38 @@ function registerTaskDelivery(server, service) {
                 language: input.language,
             },
         };
-        const ids = [
-            'commit',
-            'commit_push',
-            'commit_push_draft_pr',
-            'commit_push_pr',
-            'abandon',
-            'defer',
-        ];
+        const ids = offered(policy, fix);
+        const line = fix || policy === 'none'
+            ? ''
+            : policy === 'required'
+                ? copy.reviewRequired
+                : copy.reviewOptional;
+        if (line === undefined || ids.some((id) => !wording(copy, policy, id)))
+            return output({
+                ok: false,
+                error: {
+                    kind: 'delivery',
+                    message: "The delivery question has no code review text in the conversation language, and this project's question needs it. Ask again in a language Engineering Memory offers.",
+                    recovery: 'task.delivery',
+                    retryable: false,
+                },
+            });
         const form = await askQuestionnaire(server, service, {
             repoRoot: input.repoRoot,
             presentation: input.presentation,
             questionnaireId,
             language,
             impact: 'critical',
-            message: format(wording.message, language, { task: record.externalTaskId }),
-            context: wording.context + (record.branch ? '\n' + copy.destination + ': ' + record.branch : ''),
-            example: wording.example,
-            options: ids.map((id) => ({
-                id,
-                label: id === 'abandon' ? wording.abandon.label : copy[id].label,
-                description: id === 'abandon' ? wording.abandon.description : copy[id].description,
-            })),
+            message: format(recordCopy.message, language, { task: record.externalTaskId }),
+            context: recordCopy.context +
+                (record.branch ? '\n' + copy.destination + ': ' + record.branch : '') +
+                (line ? '\n' + line : ''),
+            example: recordCopy.example,
+            options: [
+                ...ids.map((id) => ({ id, ...wording(copy, policy, id) })),
+                { id: 'abandon', ...recordCopy.abandon },
+                { id: 'defer', ...copy.defer },
+            ],
             binding,
         }, context, [], owner);
         const choice = answerChoice(form);
@@ -466,7 +594,7 @@ function registerTaskDelivery(server, service) {
                 reason: 'abandoned',
             }));
         let baseBranch;
-        if (choice === 'commit_push_draft_pr' || choice === 'commit_push_pr') {
+        if (pullRequest(choice)) {
             const base = await askPullRequestBase(server, service, context, {
                 ...input,
                 questionnaireId: 'task-delivery-base-' + sha256(questionnaireId + choice),
@@ -495,10 +623,17 @@ function registerTaskDelivery(server, service) {
             projectId: input.projectId,
             taskId: input.taskId,
             expectedVersion: record.lockVersion,
-            choice,
+            choice: choice === 'commit_push_review_pr' ? 'commit_push_draft_pr' : choice,
             ...(baseBranch ? { baseBranch } : {}),
+            ...(pullRequest(choice) && record.reviewPolicy
+                ? { expectedReviewPolicy: record.reviewPolicy }
+                : {}),
             answerSource: answerSourceName(question.answerSource),
         });
+        const changed = answer.error?.details
+            ?.reviewPolicy;
+        if (changed)
+            return settingChanged('task.delivery', changed);
         if (!answer.ok)
             return output(answer);
         return output({