engineering-memory 1.11.27 → 1.11.29

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,10 +81,53 @@ 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);
+    registerTaskOpenReviewRequest(server, service);
+    registerGitLabToken(server, service);
     server.registerTool('task.close', {
         description: 'Close the verified task, then open its durable mode-governed Git delivery selector in the same call. Memory publication is separate. Cancellation/feedback leave delivery pending; retry identical input to resume. PR/MR is one review-request concept, not an instruction to merge. No Git action is performed by this tool. Read-only tasks need no delivery. Supply complete copy when the product text catalogue lacks the conversation language. If the user already explicitly chose Git delivery in their own message, deliveryInstruction preserves that choice with its exact relevant excerpt; it is an agent-reported instruction, never a native answer or a substitute for missing user consent. Do not use it for agent decisions or memory-publication approval.',
         inputSchema: z.object({
@@ -77,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(),
             })
@@ -121,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({
@@ -128,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;
@@ -150,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 = {
@@ -161,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, {
@@ -190,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;
@@ -225,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))
@@ -240,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,
@@ -297,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 });
@@ -311,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: {
@@ -350,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(' '),
                 },
             });
         }
@@ -373,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: {
@@ -408,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 = {
@@ -421,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);
@@ -464,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),
@@ -493,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({
@@ -536,6 +673,60 @@ function registerTaskReviewRequest(server, service) {
         });
     });
 }
+function registerTaskOpenReviewRequest(server, service) {
+    server.registerTool('task.open_review_request', {
+        description: "Open the merge request of a delivered task on GitLab from this computer and record it, in one call. It works for a GitLab only this computer's network reaches, with the user's own token saved on this computer through gitlab.token. The target branch and draft come from the delivery answer unless given here. The branch must already be on GitLab with the delivered commit. An open merge request of the branch is reused, never opened twice. When it refuses, it says why and what works instead; opening the merge request in GitLab by hand and recording it with task.review_request always works.",
+        inputSchema: z.strictObject({
+            projectId: z.string().uuid(),
+            taskId: z.string().uuid(),
+            repoRoot: z.string().min(1).optional(),
+            targetBranch: z.string().trim().min(1).max(240).optional(),
+            draft: z.boolean().optional(),
+            title: z
+                .string()
+                .trim()
+                .min(1)
+                .max(200)
+                .regex(/^[^\r\n]+$/)
+                .optional(),
+            description: z.string().trim().min(1).max(4000).optional(),
+        }),
+    }, async (input) => {
+        const result = await service.taskOpenReviewRequest(input);
+        if (!result.ok)
+            return output(result);
+        const data = result.data;
+        const opened = data.mergeRequest;
+        const said = opened
+            ? `${opened.reused ? 'The branch already had an open merge request, and it is used' : 'The merge request is opened'}: ${opened.url} (${opened.state}, into ${opened.targetBranch}).`
+            : '';
+        return output({
+            ok: true,
+            data: {
+                ...data,
+                nextAction: data.alreadyRecorded
+                    ? `This delivery already has its merge request recorded: ${data.alreadyRecorded.url} (${data.alreadyRecorded.state}). Nothing was opened. When the user says its state changed, record that with task.review_request.`
+                    : data.reportRefused
+                        ? `${said} Recording it in Engineering Memory was refused: ${data.reportRefused} Tell the user; once the cause is fixed, record it with task.review_request.`
+                        : data.report?.queued
+                            ? `${said} Engineering Memory is unreachable, so recording it is queued; it is recorded, and the work item moves, when Engineering Memory is reachable again.`
+                            : `${said} ${data.report?.data?.reviewEvent?.nextAction ??
+                                (data.report?.data?.reviewEvent
+                                    ? 'It is recorded; the work item stays where it is.'
+                                    : 'It is recorded. The work item does not move yet: other work on it is still open or undelivered, or the task has no active work item.')}`,
+            },
+        });
+    });
+}
+function registerGitLabToken(server, service) {
+    server.registerTool('gitlab.token', {
+        description: "Give the user a page on this computer where they save their own GitLab personal access token, so task.open_review_request can open merge requests and Engineering Memory can follow them on a GitLab only this computer's network reaches. The token is typed only on that page: it never passes through the chat, this agent or Engineering Memory's server, and it is kept in this computer's credential store for the signed-in account. Never open or fill in the page yourself. The same page removes a saved token.",
+        inputSchema: z.strictObject({
+            repoRoot: z.string().min(1).optional(),
+            language: languageTag.optional(),
+        }),
+    }, async (input) => output(await service.gitlabToken(input)));
+}
 function askPullRequestBase(server, service, context, input, language, copy, owner) {
     return askQuestionnaire(server, service, {
         repoRoot: input.repoRoot,