engineering-memory 1.11.29 → 1.11.31

package/runtime/dist/src/runtime/bridge-service.js

@@ -15,7 +15,7 @@ import { minimatch } from 'minimatch';
 import { endpoints } from '../config.js';
 import { startPhaseTimer } from './phase-timer.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
-import { ApiResponseError, BackendUnavailableError, } from './api-client.js';
+import { ApiResponseError, BackendUnavailableError, backendRejectsField, } from './api-client.js';
 import { assertSafeToPersist, normalizeRepositoryPaths } from './offline-outbox.js';
 import { restrictedValueKind } from './privacy-detector.js';
 import { principalFingerprint } from './principal-state.js';
@@ -26,6 +26,7 @@ import { BridgeRecoveryError } from './recovery-error.js';
 import { gitLabRemote } from '../providers/gitlab.js';
 import { awaitsReviewRequest, concludedReview, opensAsDraft, reviewDeliveries, reviewDeliverySchema, waitingReview, } from './merge-request-sync.js';
 import { maskFinding } from './review-masking.js';
+import { commentReviewSchema, dueComment, markComment } from './review-comment.js';
 export const validationIds = [
     'format',
     'static_analysis',
@@ -4360,6 +4361,89 @@ export class BridgeService {
             return asJsonValue(response.data);
         });
     }
+    async jiraProjectState(input) {
+        return await this.execute(async () => {
+            const projectId = input.projectId ?? (await this.jiraBoundProject(input.repoRoot));
+            const response = await this.dependencies.client.request(endpoints.projectJira(projectId));
+            return asJsonValue(response.data);
+        });
+    }
+    async jiraOrganizationStatus(organizationId) {
+        return await this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.jiraStatus(organizationId));
+            return asJsonValue(response.data);
+        });
+    }
+    async jiraConnectStart(input) {
+        return await this.execute(async () => {
+            const connector = this.dependencies.jiraConnect;
+            if (!connector)
+                throw refuse('This bridge was started without Jira support. Update Engineering Memory and run jira.connect again.', 'jira.status');
+            const current = connector.state(input.organizationId);
+            if (current && !input.restart && current.phase !== 'expired')
+                return asJsonValue(current);
+            return asJsonValue(await connector.start(input.organizationId, input.projectId));
+        });
+    }
+    async jiraConnectForget(organizationId) {
+        await this.dependencies.jiraConnect?.forget(organizationId);
+    }
+    async jiraChooseSite(input) {
+        return await this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.jiraConnectSite(input.organizationId), { method: 'POST', body: { requestId: input.requestId, cloudId: input.cloudId } });
+            return asJsonValue(response.data);
+        });
+    }
+    async jiraDisconnect(input) {
+        return await this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.jiraDisconnect(input.organizationId, input.connectionId), { method: 'POST' });
+            return asJsonValue(response.data);
+        });
+    }
+    async jiraProjects(input) {
+        return await this.execute(async () => {
+            const query = input.key ? `?${new URLSearchParams({ key: input.key })}` : '';
+            const response = await this.dependencies.client.request(endpoints.projectJiraProjects(input.projectId, input.connectionId) + query);
+            return asJsonValue(response.data);
+        });
+    }
+    async jiraLink(input) {
+        return await this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.projectJiraLink(input.projectId), {
+                method: 'PUT',
+                body: {
+                    connectionId: input.connectionId,
+                    jiraProjectId: input.jiraProjectId,
+                    ...(input.replace ? { replace: true } : {}),
+                },
+            });
+            return asJsonValue(response.data);
+        });
+    }
+    async jiraUnlink(projectId) {
+        return await this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.projectJiraUnlink(projectId), { method: 'POST' });
+            return asJsonValue(response.data);
+        });
+    }
+    async jiraPeople(input) {
+        return await this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.jiraPeople(input.organizationId, input.connectionId));
+            return asJsonValue(response.data);
+        });
+    }
+    async jiraDecidePeople(input) {
+        return await this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.jiraPeopleDecisions(input.organizationId, input.connectionId), { method: 'POST', body: { decisions: input.decisions } });
+            return asJsonValue(response.data);
+        });
+    }
+    async jiraBoundProject(repoRoot) {
+        const repository = await this.dependencies.repositories.resolveIdentity(repoRoot ?? process.cwd());
+        if (!repository.projectId)
+            throw refuse('This repository has no selected project. Name the projectId, or the organizationId for the organization-wide Jira tools.', 'session.entry');
+        return repository.projectId;
+    }
     async boundProject(repoRoot) {
         const repository = await this.dependencies.repositories.resolveIdentity(repoRoot ?? process.cwd());
         if (!repository.projectId)
@@ -4410,6 +4494,9 @@ export class BridgeService {
                 .object({
                 total: z.number().int(),
                 items: z.array(reviewDeliverySchema.extend({
+                    reviewReopenReason: z.string().nullish(),
+                    providerJobSince: z.string().nullish(),
+                    providerFailure: z.string().nullish(),
                     openRound: z.object({ number: z.number().int(), createdAt: z.string() }).nullish(),
                     openFindings: z.number().int(),
                 })),
@@ -4424,15 +4511,25 @@ export class BridgeService {
                     externalTaskId: item.externalTaskId ?? null,
                     workItemKey: item.workItemKey ?? null,
                     reviewState: item.reviewState ?? null,
+                    reopened: item.reviewReopenReason ?? null,
                     pullRequest: item.reviewRequest
                         ? { url: item.reviewRequest.url, state: item.reviewRequest.state }
                         : null,
+                    readyBeforeReview: waitingReview.includes(item.reviewState ?? '') && item.reviewRequest?.state === 'ready',
+                    pullRequestChange: item.providerJob
+                        ? {
+                            job: item.providerJob,
+                            since: item.providerJobSince ?? null,
+                            failure: item.providerFailure ?? null,
+                            failedAt: item.providerFailedAt ?? null,
+                        }
+                        : null,
                     openRound: item.openRound
                         ? { number: item.openRound.number, since: item.openRound.createdAt }
                         : null,
                     openFindings: item.openFindings,
                 })),
-                nextAction: 'These deliveries wait for code review. Mention them to the user in one line and start nothing on your own. When the user asks, review.get reads one and review.start runs its next round from a clone of this project; a review that ended while its PR/MR is still a draft waits for review.make_ready.',
+                nextAction: 'These deliveries wait for code review. Mention them to the user in one line and start nothing on your own. When the user asks, review.get reads one and review.start runs its next round from a clone of this project; a review that ended while its PR/MR is still a draft waits for review.make_ready. reopened (new_commit or new_target) means the review had passed and then a new commit or a new target branch arrived, so it waits again; readyBeforeReview means its PR/MR was made ready while the review had not ended; pullRequestChange is a make-ready or make-draft that a member computer with a GitLab token does in the background, with the last failure when one was recorded.',
             });
         }
         catch {
@@ -4590,6 +4687,7 @@ export class BridgeService {
                 await this.dependencies.credentials.clear();
             }
             await this.dependencies.browserAuth.dispose();
+            await this.dependencies.jiraConnect?.dispose();
             return asJsonValue({ loggedOut: true, remoteRevoked, remoteStatus });
         }, true);
     }
@@ -4757,7 +4855,18 @@ export class BridgeService {
         return this.execute(() => this.mutateWithOutbox('task.delivery', endpoints.taskDeliveryCancel(input.projectId, input.taskId), { reason: input.reason }));
     }
     async taskReviewRequest(input) {
-        return this.execute(() => this.mutateWithOutbox('task.review_request', endpoints.taskReviewRequest(input.projectId, input.taskId), { url: input.url, state: input.state }));
+        return this.execute(() => {
+            const report = (reading) => this.mutateWithOutbox('task.review_request', endpoints.taskReviewRequest(input.projectId, input.taskId), cleanJson({
+                url: input.url,
+                state: input.state,
+                ...(reading ? { headCommit: input.headCommit, targetBranch: input.targetBranch } : {}),
+            }));
+            return report(true).catch((error) => {
+                if (!backendRejectsField(error, ['headCommit', 'targetBranch']))
+                    throw error;
+                return report(false);
+            });
+        });
     }
     async taskOpenReviewRequest(input) {
         return this.execute(async () => {
@@ -4882,7 +4991,7 @@ export class BridgeService {
                     : `No code review was asked for ${task}. A review starts when its delivery chooses a reviewed PR/MR, or, where review is required, when its PR/MR is recorded.`, 'review.get');
             if (delivery.state !== 'delivered' || !delivery.pushed || !delivery.branch)
                 throw refuse(`${task} is not pushed yet, and a review reads the pushed branch. Push it and record the delivery (worktree.release with deliveryOutcome delivered), then call review.start again.`, 'review.get');
-            const target = input.targetBranch ?? delivery.baseBranch;
+            const target = input.targetBranch ?? delivery.reviewRequest?.targetBranch ?? delivery.baseBranch;
             if (!target)
                 throw refuse(`The delivery of ${task} names no target branch. Call review.start again with targetBranch: the branch its PR/MR goes into.`, 'review.start');
             const git = this.dependencies.repositories.git;
@@ -4894,9 +5003,18 @@ export class BridgeService {
             if (!tip)
                 throw refuse(`The target branch ${target} could not be fetched from origin. If the PR/MR goes into another branch, call review.start again with targetBranch.`, 'review.start');
             const base = await git.mergeBase(repository.repoRoot, head.sourceCommit, tip.sourceCommit);
-            const started = reviewSchema.parse((await this.dependencies.client.request(endpoints.reviewRounds(input.projectId, input.taskId), {
+            const startRound = (withTarget) => this.dependencies.client.request(endpoints.reviewRounds(input.projectId, input.taskId), {
                 method: 'POST',
-                body: cleanJson({ commit: head.sourceCommit, baseCommit: base ?? undefined }),
+                body: cleanJson({
+                    commit: head.sourceCommit,
+                    baseCommit: base ?? undefined,
+                    targetBranch: withTarget ? target : undefined,
+                }),
+            });
+            const started = reviewSchema.parse((await startRound(true).catch((error) => {
+                if (!backendRejectsField(error, ['targetBranch']))
+                    throw error;
+                return startRound(false);
             })).data);
             const round = started.rounds.find((candidate) => candidate.state === 'open');
             if (!round)
@@ -4904,6 +5022,12 @@ export class BridgeService {
             const files = base
                 ? await git.changedFiles(repository.repoRoot, base, head.sourceCommit)
                 : [];
+            const previous = started.rounds.find((candidate) => candidate.state === 'submitted' && candidate.number < round.number);
+            const since = previous &&
+                previous.headCommit !== head.sourceCommit &&
+                (await git.isAncestor(repository.repoRoot, previous.headCommit, head.sourceCommit))
+                ? await git.changedFiles(repository.repoRoot, previous.headCommit, head.sourceCommit)
+                : null;
             const records = await this.dependencies.client.request(`${endpoints.reviewRoundRules(input.projectId, round.id)}?offset=0&limit=5`);
             const range = base ? `${base} ${head.sourceCommit}` : head.sourceCommit;
             return asJsonValue({
@@ -4925,22 +5049,36 @@ export class BridgeService {
                 },
                 changedFiles: files.slice(0, 300),
                 changedFileCount: files.length,
+                ...(previous && since
+                    ? {
+                        sinceLastRound: {
+                            commit: previous.headCommit,
+                            changedFiles: since.slice(0, 300),
+                            changedFileCount: since.length,
+                        },
+                    }
+                    : {}),
                 earlierFindings: round.number > 1 ? started.findings : [],
                 records: records.data,
-                commands: base
-                    ? [
-                        `git diff --stat ${range}`,
-                        `git diff ${range} -- <path>`,
-                        `git show ${head.sourceCommit}:<path>`,
-                        `git grep -n <pattern> ${head.sourceCommit} -- <path>`,
-                        `git log --oneline ${base}..${head.sourceCommit}`,
-                    ]
-                    : [
-                        `git show --stat ${head.sourceCommit}`,
-                        `git show ${head.sourceCommit}:<path>`,
-                        `git grep -n <pattern> ${head.sourceCommit} -- <path>`,
-                    ],
-                nextAction: `Give this packet to a fresh subagent that did not write the change; if your host cannot start one, review it yourself under the same rules. The reviewer reads the change from baseCommit to headCommit only through the listed read-only Git commands: it never checks out, switches branches, edits, commits or pushes, and changes no file. It judges the change against the records (more with review.rules for this round from offset 5 while more are listed) and says whether each earlier finding still holds. Each finding names the file path, the line in headCommit when there is one, the ruleKey of the record it breaks when one applies, and a plain description of what is wrong and why. Then call review.submit with this projectId, roundId and the findings, an empty list when there are none.`,
+                commands: [
+                    ...(base
+                        ? [
+                            `git diff --stat ${range}`,
+                            `git diff ${range} -- <path>`,
+                            `git show ${head.sourceCommit}:<path>`,
+                            `git grep -n <pattern> ${head.sourceCommit} -- <path>`,
+                            `git log --oneline ${base}..${head.sourceCommit}`,
+                        ]
+                        : [
+                            `git show --stat ${head.sourceCommit}`,
+                            `git show ${head.sourceCommit}:<path>`,
+                            `git grep -n <pattern> ${head.sourceCommit} -- <path>`,
+                        ]),
+                    ...(previous && since
+                        ? [`git diff ${previous.headCommit} ${head.sourceCommit} -- <path>`]
+                        : []),
+                ],
+                nextAction: `Give this packet to a fresh subagent that did not write the change; if your host cannot start one, review it yourself under the same rules. The reviewer reads the change from baseCommit to headCommit only through the listed read-only Git commands: it never checks out, switches branches, edits, commits or pushes, and changes no file. It judges the change against the records (more with review.rules for this round from offset 5 while more are listed) and says whether each earlier finding still holds${previous && since ? ', starting from sinceLastRound: what changed since the previous round' : ''}. Each finding names the file path, the line in headCommit when there is one, the ruleKey of the record it breaks when one applies, and a plain description of what is wrong and why. Then call review.submit with this projectId, roundId and the findings, an empty list when there are none.`,
             });
         });
     }
@@ -4971,14 +5109,20 @@ export class BridgeService {
             }));
             const idempotencyKey = deterministicUuid('review.submit', input.roundId, stableStringify(findings));
             const response = await this.dependencies.client.request(endpoints.reviewRoundResult(input.projectId, input.roundId), { method: 'POST', body: cleanJson({ idempotencyKey, findings }) });
+            const comment = await this.reviewComment(input.projectId, response.data);
             return asJsonValue({
                 review: response.data,
                 masked: [...new Set(checked.flatMap(({ mask }) => mask.masked))],
+                ...(comment ? { comment } : {}),
             });
         });
     }
     async reviewRejectFinding(input) {
-        return this.execute(async () => asJsonValue((await this.dependencies.client.request(endpoints.reviewFindingRejection(input.projectId, input.findingId), { method: 'POST', body: { reason: input.reason } })).data));
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.reviewFindingRejection(input.projectId, input.findingId), { method: 'POST', body: { reason: input.reason } });
+            const comment = await this.reviewComment(input.projectId, response.data);
+            return asJsonValue({ ...objectOrEmpty(response.data), ...(comment ? { comment } : {}) });
+        });
     }
     async reviewConclude(input) {
         return this.execute(async () => {
@@ -4987,15 +5131,18 @@ export class BridgeService {
                 : input.outcome === 'skipped'
                     ? endpoints.reviewSkip(input.projectId, input.taskId)
                     : endpoints.reviewExemption(input.projectId, input.taskId);
-            return asJsonValue((await this.dependencies.client.request(path, {
+            const response = await this.dependencies.client.request(path, {
                 method: 'POST',
                 ...(input.outcome === 'exempted' ? { body: { reason: input.reason ?? '' } } : {}),
-            })).data);
+            });
+            const comment = await this.reviewComment(input.projectId, response.data);
+            return asJsonValue({ ...objectOrEmpty(response.data), ...(comment ? { comment } : {}) });
         });
     }
     async reviewMakeReady(input) {
         return this.execute(async () => {
-            const { delivery } = await this.review(input.projectId, input.taskId);
+            const data = (await this.dependencies.client.request(endpoints.review(input.projectId, input.taskId))).data;
+            const { delivery } = reviewSchema.parse(data);
             const task = delivery.externalTaskId;
             const request = delivery.reviewRequest;
             if (waitingReview.includes(delivery.reviewState ?? ''))
@@ -5005,32 +5152,75 @@ export class BridgeService {
                     ready: false,
                     nextAction: `No PR/MR is recorded for ${task}. Open it now as ready: on GitLab task.open_review_request with draft false; elsewhere with your own tools, then record it with task.review_request.`,
                 });
+            const comment = await this.reviewComment(input.projectId, data);
+            const commented = comment ? { comment } : {};
             if (request.state !== 'draft')
                 return asJsonValue({
                     ready: request.state === 'ready',
                     pullRequest: { url: request.url, state: request.state },
+                    ...commented,
                     nextAction: `${request.url} is ${request.state} already; nothing was changed.`,
                 });
             if (request.provider !== 'gitlab' || !this.dependencies.gitlab)
                 return asJsonValue({
                     ready: false,
                     pullRequest: { url: request.url, state: request.state },
+                    ...commented,
                     nextAction: `Mark ${request.url} ready for review with your own tools (on GitHub, gh pr ready or the "Ready for review" button), or ask the user to, then record it with task.review_request state ready.`,
                 });
-            const readied = await this.dependencies.gitlab.requests.markReady(request);
+            const readied = await this.dependencies.gitlab.requests
+                .markReady(request)
+                .catch(async (error) => {
+                const failure = error instanceof BridgeRecoveryError ? objectValue(error.details)?.failure : undefined;
+                if (delivery.providerJob === 'make_ready' && typeof failure === 'string')
+                    await this.dependencies.client
+                        .request(endpoints.reviewProviderFailure(input.projectId, input.taskId), {
+                        method: 'POST',
+                        body: { job: 'make_ready', failure },
+                    })
+                        .catch(() => undefined);
+                throw error;
+            });
             if (readied.state !== 'ready')
                 return asJsonValue({
                     ready: false,
                     pullRequest: readied,
+                    ...commented,
                     nextAction: `GitLab still shows ${readied.url} as ${readied.state}. Ask the user to mark it ready in GitLab ("Mark as ready"); Engineering Memory follows it.`,
                 });
             const report = await this.mutateWithOutbox('task.review_request', endpoints.taskReviewRequest(input.projectId, input.taskId), { url: readied.url, state: 'ready', source: 'machine' });
-            return asJsonValue({ ready: true, pullRequest: readied, report });
+            return asJsonValue({ ready: true, pullRequest: readied, ...commented, report });
         });
     }
     async review(projectId, taskId) {
         return reviewSchema.parse((await this.dependencies.client.request(endpoints.review(projectId, taskId))).data);
     }
+    async reviewComment(projectId, data) {
+        const review = commentReviewSchema.safeParse(data);
+        const request = review.success ? review.data.delivery.reviewRequest : null;
+        const comment = review.success && request ? dueComment(review.data, (await this.language()) ?? 'en') : null;
+        if (!review.success || !request || !comment)
+            return null;
+        const taskId = review.data.delivery.taskId;
+        if (request.provider === 'gitlab' && this.dependencies.gitlab) {
+            const written = await this.dependencies.gitlab.requests.comment(projectId, taskId, request, comment);
+            if (written.posted)
+                return { posted: true };
+            return {
+                posted: false,
+                ...(written.failure ? { failure: written.failure } : {}),
+                nextAction: written.failure
+                    ? `GitLab refused the review comment on ${request.url} (${written.failure.replace(/_/g, ' ')}); a member computer with a GitLab token writes it later, and nothing waits for it.`
+                    : `No GitLab token is saved on this computer, so the review comment was not written on ${request.url}; a member computer with a GitLab token writes it later, and gitlab.token lets this computer write it too.`,
+            };
+        }
+        await markComment(this.dependencies.client, projectId, taskId, comment);
+        return {
+            posted: false,
+            body: comment.body,
+            nextAction: `Post body unchanged as a comment on ${request.url} with your own tools (on GitHub, gh pr comment with the body in a file), so the team sees the review there. It is recorded as handed over and is not handed over again.`,
+        };
+    }
     async reportDeliveryOutcome(report) {
         const path = report.outcome === 'delivered'
             ? endpoints.taskDeliveryDeliver(report.projectId, report.taskId)
@@ -6241,11 +6431,6 @@ function classifyError(error) {
     }
     return 'bridge_delivery_error';
 }
-function backendRejectsField(error, fields) {
-    return (error instanceof ApiResponseError &&
-        error.httpStatus === 400 &&
-        fields.some((field) => error.message.includes(`property ${field} should not exist`)));
-}
 function isDefinitiveAuthenticationFailure(error) {
     return (error instanceof ApiResponseError &&
         (error.httpStatus === 400 || error.httpStatus === 401 || error.httpStatus === 403));

package/runtime/dist/src/runtime/create-bridge-service.js

@@ -22,6 +22,7 @@ import { PrincipalStateGuard, principalFingerprint } from './principal-state.js'
 import { MergeRequests } from './merge-request-sync.js';
 import { GitLabClient, GitLabTokens } from '../providers/gitlab.js';
 import { GitLabTokenPage } from '../providers/gitlab-token-page.js';
+import { JiraConnectCoordinator } from '../providers/jira-connect.js';
 import { OnboardingStore } from './onboarding-store.js';
 import { QuestionnaireStore } from './questionnaire-store.js';
 import { sha256 } from '../utilities/hash.js';
@@ -113,8 +114,9 @@ export function createBridgeService(options = {}) {
         gitlab: {
             tokens: gitlabTokens,
             page: new GitLabTokenPage(gitlabTokens, gitlab, signedInLanguage),
-            requests: new MergeRequests(client, gitlabTokens, gitlab, git),
+            requests: new MergeRequests(client, gitlabTokens, gitlab, git, signedInLanguage),
         },
+        jiraConnect: new JiraConnectCoordinator(client, signedInLanguage),
     }));
 }
 //# sourceMappingURL=create-bridge-service.js.map

package/runtime/dist/src/runtime/live-signals.js

@@ -29,6 +29,9 @@ const kindByPrefix = [
     ['sync-start-', 'project_onboarding'],
     ['workflow-apply-', 'project_onboarding'],
     ['status-description-', 'project_onboarding'],
+    ['review-policy-', 'review_decision'],
+    ['review-reject-', 'review_decision'],
+    ['review-conclude-', 'review_decision'],
 ];
 export function liveQuestionKind(record) {
     if (record.owner?.tool === 'decision.mode')

package/runtime/dist/src/runtime/merge-request-sync.js

@@ -2,7 +2,9 @@ import { randomUUID } from 'node:crypto';
 import * as z from 'zod/v4';
 import { endpoints } from '../config.js';
 import { GitLabError, gitLabRemote, projectPath, reviewState, } from '../providers/gitlab.js';
+import { backendRejectsField } from './api-client.js';
 import { BridgeRecoveryError } from './recovery-error.js';
+import { commentReviewSchema, dueComment, markComment } from './review-comment.js';
 export const reviewDeliverySchema = z.object({
     taskId: z.string(),
     externalTaskId: z.string().nullish(),
@@ -14,6 +16,10 @@ export const reviewDeliverySchema = z.object({
     branch: z.string().nullish(),
     workItemKey: z.string().nullish(),
     reviewState: z.string().nullish(),
+    reviewCommit: z.string().nullish(),
+    reviewCommentPostedAt: z.string().nullish(),
+    providerJob: z.string().nullish(),
+    providerFailedAt: z.string().nullish(),
     reviewRequest: z
         .object({
         provider: z.string(),
@@ -23,6 +29,7 @@ export const reviewDeliverySchema = z.object({
         url: z.string(),
         state: z.string(),
         source: z.string().optional(),
+        targetBranch: z.string().nullish(),
     })
         .nullish(),
 });
@@ -54,13 +61,16 @@ export class MergeRequests {
     tokens;
     gitlab;
     git;
+    language;
     passes = new Map();
     running = new Set();
-    constructor(client, tokens, gitlab, git) {
+    readingRefused = false;
+    constructor(client, tokens, gitlab, git, language) {
         this.client = client;
         this.tokens = tokens;
         this.gitlab = gitlab;
         this.git = git;
+        this.language = language;
     }
     async open(input) {
         const delivery = reviewDeliverySchema.parse((await this.client.request(endpoints.taskDelivery(input.projectId, input.taskId)))
@@ -166,6 +176,21 @@ export class MergeRequests {
                 : 'review.make_ready', { address: at, failure: error.failure, status: error.status });
         }
     }
+    async comment(projectId, taskId, request, comment) {
+        const link = await this.tokens.forLink(request.host, request.repository);
+        const token = link ? await this.tokens.token(link.address) : null;
+        if (!link || !token)
+            return { posted: false };
+        try {
+            await this.post(projectId, taskId, { address: link.address, token, project: link.project, number: request.number }, comment);
+            return { posted: true };
+        }
+        catch (error) {
+            if (!(error instanceof GitLabError))
+                throw error;
+            return { posted: false, failure: error.failure };
+        }
+    }
     schedule(projectId, repoRoot, deliveries) {
         const now = Date.now();
         const last = this.passes.get(projectId);
@@ -192,8 +217,17 @@ export class MergeRequests {
         const worker = async () => {
             for (let delivery = queue.shift(); delivery && pass.calls > 0; delivery = queue.shift()) {
                 const found = await this.follow(delivery, repoRoot, pass).catch(() => null);
-                if (found && (await this.report(projectId, delivery.taskId, found)))
+                if (!found)
+                    continue;
+                let job = delivery.providerJob ?? null;
+                if (this.changed(delivery, found)) {
+                    const answer = await this.report(projectId, delivery.taskId, found);
+                    if (!answer)
+                        continue;
                     reported++;
+                    job = answer.providerJob;
+                }
+                await this.provide(projectId, delivery, found, job, pass).catch(() => undefined);
             }
         };
         await Promise.all([worker(), worker(), worker(), worker()]);
@@ -209,10 +243,9 @@ export class MergeRequests {
             if (!link || !token)
                 return null;
             const request = await this.call(pass, link.address, () => this.gitlab.mergeRequest(link.address, token, link.project, known.number));
-            if (!request)
-                return null;
-            const state = reviewState(request);
-            return state !== known.state || known.source !== 'machine' ? { url: known.url, state } : null;
+            return request
+                ? { url: known.url, request, address: link.address, token, project: link.project }
+                : null;
         }
         if (!repoRoot || !delivery.branch)
             return null;
@@ -242,7 +275,78 @@ export class MergeRequests {
             .sort((left, right) => rank(left) - rank(right) ||
             Number(right.sha === delivery.deliveredCommit) -
                 Number(left.sha === delivery.deliveredCommit))[0];
-        return chosen ? { url: chosen.web_url, state: reviewState(chosen) } : null;
+        return chosen ? { url: chosen.web_url, request: chosen, address, token, project: path } : null;
+    }
+    changed(delivery, found) {
+        const known = delivery.reviewRequest;
+        const head = found.request.sha;
+        return (!known ||
+            reviewState(found.request) !== known.state ||
+            known.source !== 'machine' ||
+            (known.targetBranch !== undefined && found.request.target_branch !== known.targetBranch) ||
+            (!this.readingRefused &&
+                delivery.reviewState === 'passed' &&
+                !!head &&
+                !!delivery.reviewCommit &&
+                head !== delivery.reviewCommit));
+    }
+    async provide(projectId, delivery, found, job, pass) {
+        const state = reviewState(found.request);
+        const failedAt = job === (delivery.providerJob ?? null) ? delivery.providerFailedAt : null;
+        if ((state !== 'draft' && state !== 'ready') ||
+            (failedAt && Date.now() - Date.parse(failedAt) < 30 * 60 * 1000) ||
+            pass.failed.has(found.address) ||
+            pass.calls < 3)
+            return;
+        if (delivery.reviewState === 'findings_open' ||
+            (concludedReview.includes(delivery.reviewState ?? '') &&
+                delivery.reviewCommentPostedAt === null)) {
+            const review = commentReviewSchema.safeParse((await this.client
+                .request(endpoints.review(projectId, delivery.taskId))
+                .catch(() => null))?.data);
+            const comment = review.success
+                ? dueComment(review.data, (await this.language()) ?? 'en')
+                : null;
+            if (comment)
+                await this.post(projectId, delivery.taskId, { ...found, number: found.request.iid }, comment, pass).catch(() => undefined);
+        }
+        const due = (job === 'make_ready' && state === 'draft') || (job === 'make_draft' && state === 'ready')
+            ? job
+            : null;
+        if (!due)
+            return;
+        try {
+            pass.calls--;
+            const title = found.request.title;
+            if (title === undefined)
+                throw new GitLabError('unexpected_answer', found.address, null, null);
+            const after = await this.gitlab.retitleMergeRequest(found.address, found.token, found.project, found.request.iid, due === 'make_ready'
+                ? title.replace(draftPrefix, '') || defaultTitle(found.request.source_branch, null)
+                : `Draft: ${title}`.slice(0, 255));
+            await this.report(projectId, delivery.taskId, { ...found, request: after });
+        }
+        catch (error) {
+            if (!(error instanceof GitLabError))
+                return;
+            pass.failed.add(found.address);
+            await this.client
+                .request(endpoints.reviewProviderFailure(projectId, delivery.taskId), {
+                method: 'POST',
+                body: { job: due, failure: error.failure },
+            })
+                .catch(() => undefined);
+        }
+    }
+    async post(projectId, taskId, target, comment, pass) {
+        if (pass)
+            pass.calls--;
+        const notes = await this.gitlab.notes(target.address, target.token, target.project, target.number);
+        if (!notes.some((note) => note.body.includes(comment.marker))) {
+            if (pass)
+                pass.calls--;
+            await this.gitlab.createNote(target.address, target.token, target.project, target.number, comment.body);
+        }
+        await markComment(this.client, projectId, taskId, comment);
     }
     async call(pass, address, request) {
         if (pass.failed.has(address) || pass.calls <= 0)
@@ -259,16 +363,28 @@ export class MergeRequests {
         }
     }
     async report(projectId, taskId, found) {
+        const body = { url: found.url, state: reviewState(found.request), source: 'machine' };
+        const reading = {
+            ...(found.request.sha ? { headCommit: found.request.sha } : {}),
+            targetBranch: found.request.target_branch,
+        };
+        const send = () => this.client.request(endpoints.taskReviewRequest(projectId, taskId), {
+            method: 'POST',
+            body: this.readingRefused ? body : { ...body, ...reading },
+            idempotencyKey: randomUUID(),
+        });
         try {
-            await this.client.request(endpoints.taskReviewRequest(projectId, taskId), {
-                method: 'POST',
-                body: { url: found.url, state: found.state, source: 'machine' },
-                idempotencyKey: randomUUID(),
+            const response = await send().catch(async (error) => {
+                if (this.readingRefused || !backendRejectsField(error, ['headCommit', 'targetBranch']))
+                    throw error;
+                this.readingRefused = true;
+                return send();
             });
-            return true;
+            const answer = z.object({ providerJob: z.string().nullish() }).safeParse(response.data);
+            return { providerJob: answer.success ? (answer.data.providerJob ?? null) : null };
         }
         catch {
-            return false;
+            return null;
         }
     }
 }