plugin-git-manager 1.1.9 → 1.1.12

package/src/client/context/GitManagerContext.tsx

@@ -8,6 +8,8 @@ interface Repository {
   localPath: string;
   defaultBranch: string;
   status: string;
+  autoReview?: boolean;
+  autoReviewFlowId?: number | null;
 }
 
 interface GitManagerContextType {

package/src/client/index.tsx

@@ -1,31 +1,31 @@
-import { Plugin } from '@nocobase/client';
-import React from 'react';
-import {
-  GitRepositoryWorkContext,
-  GitMergeRequestWorkContext,
-  GitCommitWorkContext,
-} from './ai-context';
-
-const GitManagerSettings = React.lazy(() =>
-  import('./components/GitManagerSettings').then((m) => ({ default: m.GitManagerSettings })),
-);
-
-export class PluginGitManagerClient extends Plugin {
-  async load() {
-    this.app.pluginSettingsManager.add('git-manager', {
-      title: this.t('Git Manager'),
-      icon: 'BranchesOutlined',
-      Component: GitManagerSettings,
-      aclSnippet: 'pm.plugin-git-manager',
-    });
-
-    const aiManager = (this.app as any).aiManager;
-    if (aiManager?.registerWorkContext) {
-      aiManager.registerWorkContext('git-repository', GitRepositoryWorkContext);
-      aiManager.registerWorkContext('git-merge-request', GitMergeRequestWorkContext);
-      aiManager.registerWorkContext('git-commit', GitCommitWorkContext);
-    }
-  }
-}
-
-export default PluginGitManagerClient;
+import { Plugin } from '@nocobase/client';
+import React from 'react';
+import {
+  GitRepositoryWorkContext,
+  GitMergeRequestWorkContext,
+  GitCommitWorkContext,
+} from './ai-context';
+
+const GitManagerSettings = React.lazy(() =>
+  import('./components/GitManagerSettings').then((m) => ({ default: m.GitManagerSettings })),
+);
+
+export class PluginGitManagerClient extends Plugin {
+  async load() {
+    (this as any).app.pluginSettingsManager.add('git-manager', {
+      title: (this as any).t('Git Manager'),
+      icon: 'BranchesOutlined',
+      Component: GitManagerSettings,
+      aclSnippet: 'pm.plugin-git-manager',
+    });
+
+    const aiManager = ((this as any).app as any).aiManager;
+    if (aiManager?.registerWorkContext) {
+      aiManager.registerWorkContext('git-repository', GitRepositoryWorkContext);
+      aiManager.registerWorkContext('git-merge-request', GitMergeRequestWorkContext);
+      aiManager.registerWorkContext('git-commit', GitCommitWorkContext);
+    }
+  }
+}
+
+export default PluginGitManagerClient;

package/src/locale/en-US.json

@@ -125,6 +125,8 @@
   "Posted": "Posted",
   "Pending Approval": "Pending Approval",
   "Approved": "Approved",
+  "Post Failed": "Post Failed",
+  "post_failed": "Post failed",
   "Rejected": "Rejected",
   "Skipped": "Skipped",
   "Running": "Running",
@@ -177,5 +179,12 @@
   "new": "new",
   "Reviewed SHA": "Reviewed SHA",
   "Latest SHA": "Latest SHA",
-  "All triggers": "All triggers"
+  "All triggers": "All triggers",
+  "Search commit title or message": "Search commit title or message",
+  "Primary Auto Flow": "Primary Auto Flow",
+  "Primary Auto Review Flow": "Primary Auto Review Flow",
+  "Only flows with automatic trigger modes are shown": "Only flows with automatic trigger modes are shown",
+  "Fallback": "Fallback",
+  "AI employee not found": "AI employee not found",
+  "Failed to open AI chat": "Failed to open AI chat"
 }

package/src/locale/vi-VN.json

@@ -125,6 +125,8 @@
   "Posted": "Đã đăng",
   "Pending Approval": "Chờ duyệt",
   "Approved": "Đã duyệt",
+  "Post Failed": "Đăng thất bại",
+  "post_failed": "Đăng thất bại",
   "Rejected": "Đã từ chối",
   "Skipped": "Đã bỏ qua",
   "Running": "Đang chạy",

package/src/server/actions/git-actions.ts

@@ -91,7 +91,10 @@ function getAuthUrl(repoUrl: string, pat: string, username?: string): string {
   return url.toString();
 }
 
-function getGit(localPath: string): SimpleGit {
+function getGit(ctx: Context, localPath: string): SimpleGit {
+  if (!fs.existsSync(localPath)) {
+    ctx.throw(400, 'Repository directory does not exist. Please clone the repository first.');
+  }
   return simpleGit(localPath);
 }
 
@@ -170,7 +173,7 @@ export async function pull(ctx: Context, next: () => Promise<void>) {
   const repoUrl = (repo.get('repoUrl') as string || '').trim();
   const username = (repo.get('username') as string || '').trim();
 
-  const git = getGit(localPath);
+  const git = getGit(ctx, localPath);
   const result = await withAuth(git, localPath, repoUrl, pat, () => git.pull(), username);
 
   ctx.body = { success: true, data: result };
@@ -184,7 +187,7 @@ export async function push(ctx: Context, next: () => Promise<void>) {
   const repoUrl = (repo.get('repoUrl') as string || '').trim();
   const username = (repo.get('username') as string || '').trim();
 
-  const git = getGit(localPath);
+  const git = getGit(ctx, localPath);
   const result = await withAuth(git, localPath, repoUrl, pat, () => git.push(), username);
 
   ctx.body = { success: true, data: result };
@@ -198,7 +201,7 @@ export async function fetch(ctx: Context, next: () => Promise<void>) {
   const repoUrl = (repo.get('repoUrl') as string || '').trim();
   const username = (repo.get('username') as string || '').trim();
 
-  const git = getGit(localPath);
+  const git = getGit(ctx, localPath);
   const result = await withAuth(git, localPath, repoUrl, pat, () => git.fetch(), username);
 
   ctx.body = { success: true, data: result };
@@ -210,7 +213,7 @@ export async function diff(ctx: Context, next: () => Promise<void>) {
   const localPath = validateLocalPath(repo.get('localPath'));
   const { file, commitHash, compareHash } = ctx.action.params;
 
-  const git = getGit(localPath);
+  const git = getGit(ctx, localPath);
   const args: string[] = [];
   if (commitHash && compareHash) {
     args.push(validateRef(commitHash), validateRef(compareHash));
@@ -230,7 +233,7 @@ export async function diff(ctx: Context, next: () => Promise<void>) {
 export async function status(ctx: Context, next: () => Promise<void>) {
   const repo = await getRepo(ctx);
   const localPath = validateLocalPath(repo.get('localPath'));
-  const result = await getGit(localPath).status();
+  const result = await getGit(ctx, localPath).status();
   ctx.body = { success: true, data: result };
   await next();
 }
@@ -247,7 +250,7 @@ export async function log(ctx: Context, next: () => Promise<void>) {
     options.file = file;
   }
 
-  const result = await getGit(localPath).log(options);
+  const result = await getGit(ctx, localPath).log(options);
   ctx.body = { success: true, data: result };
   await next();
 }
@@ -255,7 +258,7 @@ export async function log(ctx: Context, next: () => Promise<void>) {
 export async function branches(ctx: Context, next: () => Promise<void>) {
   const repo = await getRepo(ctx);
   const localPath = validateLocalPath(repo.get('localPath'));
-  const result = await getGit(localPath).branch();
+  const result = await getGit(ctx, localPath).branch();
   ctx.body = { success: true, data: result };
   await next();
 }
@@ -265,7 +268,7 @@ export async function checkout(ctx: Context, next: () => Promise<void>) {
   const localPath = validateLocalPath(repo.get('localPath'));
   const { branch } = ctx.action.params;
   validateBranch(branch);
-  await getGit(localPath).checkout(branch);
+  await getGit(ctx, localPath).checkout(branch);
   ctx.body = { success: true, message: `Switched to branch ${branch}` };
   await next();
 }
@@ -275,7 +278,7 @@ export async function fileTree(ctx: Context, next: () => Promise<void>) {
   const localPath = validateLocalPath(repo.get('localPath'));
   const { ref = 'HEAD', treePath = '' } = ctx.action.params;
 
-  const git = getGit(localPath);
+  const git = getGit(ctx, localPath);
   validateRef(ref);
   if (treePath && treePath.includes('..')) {
     ctx.throw(400, 'Invalid tree path');
@@ -324,7 +327,7 @@ export async function fileContent(ctx: Context, next: () => Promise<void>) {
   }
 
   validateRef(ref);
-  const git = getGit(localPath);
+  const git = getGit(ctx, localPath);
   const content = await git.show([`${ref}:${filePath}`]);
   ctx.body = { success: true, data: { content, filePath, ref } };
   await next();
@@ -339,7 +342,7 @@ export async function commitDetail(ctx: Context, next: () => Promise<void>) {
     ctx.throw(400, 'commitHash is required');
   }
 
-  const git = getGit(localPath);
+  const git = getGit(ctx, localPath);
   validateRef(commitHash);
 
   // Use %x00 in format string to tell git to output null bytes, avoiding null bytes in args

package/src/server/actions/gitlab-api.ts

@@ -1,6 +1,10 @@
 import { Context } from '@nocobase/actions';
 import { parseGitLabProject } from '../utils/gitlab-url';
 
+function getActionParams(ctx: Context) {
+  return { ...ctx.action.params, ...ctx.action.params?.values, ...((ctx as any).request?.body || {}) };
+}
+
 async function gitlabFetch(apiBase: string, endpoint: string, pat: string, params?: Record<string, any>) {
   const url = new URL(`${apiBase}${endpoint}`);
   if (params) {
@@ -33,7 +37,7 @@ async function gitlabFetch(apiBase: string, endpoint: string, pat: string, param
 
 async function getRepoApiContext(ctx: Context) {
   // Fix for POST requests where data might be in ctx.request.body
-  const params = { ...ctx.action.params, ...ctx.action.params?.values, ...( (ctx.request.body as any) || {} ) };
+  const params = getActionParams(ctx);
   const { repositoryId } = params;
   
   const repo = await ctx.db.getRepository('gitRepositories').findOne({
@@ -90,7 +94,7 @@ async function githubFetch(endpoint: string, pat: string, params?: Record<string
 export async function mergeRequests(ctx: Context, next: () => Promise<void>) {
   const { pat, apiBase, encodedProject, projectPath, isGitHub } = await getRepoApiContext(ctx);
   // Merge params from query and body
-  const params = { ...ctx.action.params, ...ctx.action.params?.values, ...( (ctx.request.body as any) || {} ) };
+  const params = getActionParams(ctx);
   const {
     state = 'opened',
     search,
@@ -207,7 +211,7 @@ export async function mergeRequests(ctx: Context, next: () => Promise<void>) {
 
 export async function mergeRequestDetail(ctx: Context, next: () => Promise<void>) {
   const { pat, apiBase, encodedProject, projectPath, isGitHub } = await getRepoApiContext(ctx);
-  const params = { ...ctx.action.params, ...ctx.action.params?.values, ...( (ctx.request.body as any) || {} ) };
+  const params = getActionParams(ctx);
   const { mrIid } = params;
 
   if (!mrIid) {
@@ -321,7 +325,7 @@ export async function mergeRequestDetail(ctx: Context, next: () => Promise<void>
 
 export async function mergeRequestNotes(ctx: Context, next: () => Promise<void>) {
   const { pat, apiBase, encodedProject, projectPath, isGitHub } = await getRepoApiContext(ctx);
-  const params = { ...ctx.action.params, ...ctx.action.params?.values, ...( (ctx.request.body as any) || {} ) };
+  const params = getActionParams(ctx);
   const { mrIid, page = 1, perPage = 50 } = params;
 
   if (!mrIid) {

package/src/server/actions/review.ts

@@ -3,6 +3,17 @@ import type { Application } from '@nocobase/server';
 import { parseGitLabProject } from '../utils/gitlab-url';
 import { redactPat } from '../utils/redact';
 
+export const WORKER_JOB_GIT_REVIEW_PROCESS = 'git-review:process';
+const REVIEW_QUEUE_CHANNEL = 'plugin-git-manager.review';
+const REVIEW_QUEUE_CONCURRENCY = Math.max(
+  1,
+  Number.parseInt(process.env.GIT_REVIEW_QUEUE_CONCURRENCY || process.env.GIT_REVIEW_MAX_CONCURRENCY || '3', 10) || 3,
+);
+const REVIEW_QUEUE_TIMEOUT_MS = Math.max(
+  60_000,
+  Number.parseInt(process.env.GIT_REVIEW_QUEUE_TIMEOUT_MS || '', 10) || 10 * 60 * 1000,
+);
+
 interface TriggerArgs {
   flowId?: number | null;
   repositoryId: number;
@@ -16,6 +27,33 @@ interface TriggerArgs {
   userId?: number | string | null;
 }
 
+interface ReviewFlowSnapshot {
+  id: number;
+  name?: string;
+  postMode?: string;
+  llmService?: string | null;
+  model?: string | null;
+  instructions?: string | null;
+}
+
+interface ReviewQueueMessage {
+  reviewId: number;
+  repositoryId: number;
+  targetType: 'mr' | 'commit' | 'branch';
+  mrIid?: number | null;
+  commitSha?: string | null;
+  branch?: string | null;
+  headSha?: string | null;
+  aiEmployeeUsername: string;
+  extraInstructions?: string;
+  userId?: number | string | null;
+  flowSnapshot?: ReviewFlowSnapshot;
+}
+
+function getActionParams(ctx: Context) {
+  return { ...ctx.action.params, ...ctx.action.params?.values, ...((ctx as any).request?.body || {}) };
+}
+
 /**
  * Per-target mutex to prevent two concurrent calls to
  * `triggerReviewInternal` for the same MR / commit / branch from racing
@@ -25,8 +63,8 @@ interface TriggerArgs {
  * Uses `app.lockManager` so the same code path covers both single-node
  * (in-memory `async-mutex`) and HA cluster (Redis-backed Redlock when
  * `plugin-cluster-manager` is active and `LOCK_ADAPTER_DEFAULT=redis`).
- * The locked region only does an upsert + setImmediate (a few ms), so a
- * 30s TTL is generous and auto-releases if the process crashes.
+ * The locked region only does an upsert + queue publish (a few ms), so a 30s
+ * TTL is generous and auto-releases if the process crashes.
  */
 function targetKey(args: TriggerArgs): string {
   if (args.targetType === 'mr') return `${args.repositoryId}:mr:${args.mrIid}`;
@@ -43,11 +81,11 @@ async function withTriggerLock<T>(app: Application, key: string, fn: () => Promi
 
 /**
  * Trigger an AI-driven code review for an MR / commit / branch.
- * The review record is upserted synchronously, then AIEmployee.invoke runs in
- * the background. The action returns immediately with the reviewId.
+ * The review record is upserted synchronously, then queued for an available
+ * git-review worker. The action returns immediately with the reviewId.
  */
 export async function triggerReview(ctx: Context, next: () => Promise<void>) {
-  const params = { ...ctx.action.params, ...ctx.action.params?.values, ...( (ctx.request.body as any) || {} ) };
+  const params = getActionParams(ctx);
   const {
     flowId,
     repositoryId,
@@ -158,13 +196,12 @@ async function triggerReviewInternalLocked(app: Application, args: TriggerArgs):
     latestSha: headSha || existingLatestSha || null,
     triggeredBy: args.triggeredBy || 'manual',
     status: 'pending',
-    // Stamp startedAt synchronously so `recoverStuckReviews` can sweep rows
-    // that get stuck in `pending` (process died before runReview ran).
-    // runReview's own update will refresh this on actual start.
-    startedAt: new Date(),
+    // `startedAt` is stamped by the queue worker when execution actually
+    // starts. Pending rows may be legitimately waiting in Redis.
+    startedAt: null,
     finishedAt: null,
     durationMs: null,
-    postStatus: flow.get('postMode') === 'disabled' ? 'skipped' : 'pending_approval',
+    postStatus: getInitialPostStatus(flow, args.targetType),
     error: null,
   };
 
@@ -189,33 +226,153 @@ async function triggerReviewInternalLocked(app: Application, args: TriggerArgs):
     reviewId = review.get('id') as number;
   }
 
-  // Run in background — do not await
-  setImmediate(() =>
-    runReview(app, {
-      reviewId,
+  // Queue for background workers; the action returns as soon as the message is published.
+  await enqueueReview(app, {
+    reviewId,
+    repositoryId: args.repositoryId,
+    targetType: args.targetType,
+    mrIid: args.targetType === 'mr' ? args.mrIid : null,
+    commitSha: args.targetType === 'commit' ? args.commitSha : null,
+    branch: args.branch || undefined,
+    headSha,
+    aiEmployeeUsername,
+    extraInstructions: args.extraInstructions,
+    userId: args.userId ?? null,
+    flowSnapshot: createFlowSnapshot(flow),
+  });
+
+  return reviewId;
+}
+
+export function registerReviewQueue(app: Application) {
+  app.eventQueue.subscribe(REVIEW_QUEUE_CHANNEL, {
+    concurrency: REVIEW_QUEUE_CONCURRENCY,
+    idle: () => isGitReviewWorker(app),
+    process: async (message: ReviewQueueMessage) => {
+      await processQueuedReview(app, message);
+    },
+  });
+}
+
+export function unregisterReviewQueue(app: Application) {
+  app.eventQueue.unsubscribe(REVIEW_QUEUE_CHANNEL);
+}
+
+function createFlowSnapshot(flow: any): ReviewFlowSnapshot {
+  return {
+    id: Number(flow.get('id')),
+    name: flow.get('name') as string,
+    postMode: flow.get('postMode') as string,
+    llmService: flow.get('llmService') as string | null,
+    model: flow.get('model') as string | null,
+    instructions: flow.get('instructions') as string | null,
+  };
+}
+
+function createFlowFromSnapshot(snapshot: ReviewFlowSnapshot | undefined, fallback?: any) {
+  return {
+    get(name: string) {
+      if (snapshot && Object.prototype.hasOwnProperty.call(snapshot, name)) {
+        return (snapshot as any)[name];
+      }
+      return fallback?.get?.(name);
+    },
+  };
+}
+
+function isGitReviewWorker(app: Application): boolean {
+  const workerMode = process.env.WORKER_MODE || '';
+  return (
+    app.serving(WORKER_JOB_GIT_REVIEW_PROCESS) ||
+    workerMode === 'worker' ||
+    workerMode === 'task' ||
+    process.env.APP_ROLE === 'worker'
+  );
+}
+
+async function enqueueReview(app: Application, message: ReviewQueueMessage) {
+  try {
+    await app.eventQueue.publish(REVIEW_QUEUE_CHANNEL, message, {
+      timeout: REVIEW_QUEUE_TIMEOUT_MS,
+      maxRetries: 1,
+    });
+  } catch (err: any) {
+    const safeMessage = redactPat(err?.message || String(err));
+    await app.db.getRepository('gitCodeReviews').update({
+      filterByTk: message.reviewId,
+      values: {
+        status: 'failed',
+        error: `Failed to enqueue review: ${safeMessage}`,
+        finishedAt: new Date(),
+      },
+    });
+    throw err;
+  }
+}
+
+async function failQueuedReview(app: Application, reviewId: number, err: any) {
+  const safeMessage = redactPat(err?.message || String(err));
+  await app.db.getRepository('gitCodeReviews').update({
+    filterByTk: reviewId,
+    values: {
+      status: 'failed',
+      error: safeMessage,
+      finishedAt: new Date(),
+    },
+  });
+}
+
+async function processQueuedReview(app: Application, message: ReviewQueueMessage) {
+  const db = app.db;
+  const reviewsRepo = db.getRepository('gitCodeReviews');
+  const review = await reviewsRepo.findOne({ filterByTk: message.reviewId });
+  if (!review) {
+    app.log?.warn?.(`git review queue: review ${message.reviewId} not found, skipping`);
+    return;
+  }
+
+  if (review.get('status') !== 'pending') {
+    app.log?.info?.(`git review queue: review ${message.reviewId} is ${review.get('status')}, skipping`);
+    return;
+  }
+
+  try {
+    const repo = await db.getRepository('gitRepositories').findOne({
+      filterByTk: message.repositoryId || review.get('repositoryId'),
+    });
+    if (!repo) throw new Error('Repository not found');
+
+    const storedFlow = await db.getRepository('gitReviewFlows').findOne({
+      filterByTk: message.flowSnapshot?.id || review.get('flowId'),
+    });
+    const flow = createFlowFromSnapshot(message.flowSnapshot, storedFlow);
+    const aiEmployeeUsername = message.aiEmployeeUsername || (flow.get('aiEmployeeUsername') as string);
+    if (!aiEmployeeUsername) throw new Error('Flow has no AI employee configured');
+
+    await runReview(app, {
+      reviewId: message.reviewId,
       flow,
       repo,
-      targetType: args.targetType,
-      mrIid: args.targetType === 'mr' ? args.mrIid! : null,
-      commitSha: args.targetType === 'commit' ? args.commitSha! : null,
-      branch: args.branch || undefined,
-      headSha,
+      targetType: message.targetType || review.get('targetType'),
+      mrIid: message.targetType === 'mr' ? message.mrIid ?? Number(review.get('mrIid')) : null,
+      commitSha: message.targetType === 'commit' ? message.commitSha || (review.get('commitSha') as string) : null,
+      branch: message.branch || (review.get('branch') as string | undefined),
+      headSha: message.headSha || (review.get('headSha') as string | null),
       aiEmployeeUsername,
-      extraInstructions: args.extraInstructions,
-      userId: args.userId ?? null,
-    }).catch((err) => {
-      app.log?.error?.('runReview background error', err);
-    }),
-  );
-
-  return reviewId;
+      extraInstructions: message.extraInstructions,
+      userId: message.userId ?? null,
+    });
+  } catch (err) {
+    app.log?.error?.('git review queue: failed before review execution', err);
+    await failQueuedReview(app, message.reviewId, err);
+  }
 }
 
 /**
  * Mark a review as approved and post its content to GitLab as an MR note.
  */
 export async function reviewApprovePost(ctx: Context, next: () => Promise<void>) {
-  const params = { ...ctx.action.params, ...ctx.action.params?.values, ...( (ctx.request.body as any) || {} ) };
+  const params = getActionParams(ctx);
   const { reviewId, editedMarkdown } = params;
   if (!reviewId) ctx.throw(400, 'reviewId is required');
 
@@ -244,6 +401,7 @@ export async function reviewApprovePost(ctx: Context, next: () => Promise<void>)
       postedNoteId: String(noteId),
       approvedBy: userId ? String(userId) : null,
       approvedAt: new Date(),
+      error: null,
     },
   });
 
@@ -255,7 +413,7 @@ export async function reviewApprovePost(ctx: Context, next: () => Promise<void>)
  * Reject a pending review (do not post to GitLab).
  */
 export async function reviewReject(ctx: Context, next: () => Promise<void>) {
-  const params = { ...ctx.action.params, ...ctx.action.params?.values, ...( (ctx.request.body as any) || {} ) };
+  const params = getActionParams(ctx);
   const { reviewId, reason } = params;
   if (!reviewId) ctx.throw(400, 'reviewId is required');
 
@@ -428,9 +586,10 @@ async function runReview(app: Application, args: RunReviewArgs) {
     const finishedAt = new Date();
     const durationMs = finishedAt.getTime() - startedAt.getTime();
 
-    const postMode = args.flow.get('postMode') as string;
-    let postStatus = 'pending_approval';
+    const postMode = getFlowPostMode(args.flow);
+    let postStatus = getInitialPostStatus(args.flow, args.targetType);
     let postedNoteId: string | null = null;
+    let autoPostError: string | null = null;
 
     if (postMode === 'disabled') {
       postStatus = 'skipped';
@@ -439,6 +598,8 @@ async function runReview(app: Application, args: RunReviewArgs) {
         postedNoteId = String(await postNoteToGitLab(args.repo, args.mrIid, content));
         postStatus = 'posted';
       } catch (err: any) {
+        autoPostError = redactPat(err?.message || String(err));
+        postStatus = 'post_failed';
         app.log?.error?.('Auto-post review note failed', err);
       }
     }
@@ -457,11 +618,14 @@ async function runReview(app: Application, args: RunReviewArgs) {
         finishedAt,
         postStatus,
         postedNoteId,
+        error: autoPostError ? `Auto-post failed: ${autoPostError}` : null,
         metadata: {
           flowName: args.flow.get('name'),
           aiEmployeeUsername: args.aiEmployeeUsername,
           llmService,
           model,
+          postMode,
+          autoPostError,
         },
       },
     });
@@ -678,6 +842,30 @@ async function postNoteToGitLab(repo: any, mrIid: number, body: string): Promise
 const MAX_BRANCH_FILTER_LENGTH = 200;
 const loggedBadFilters = new Set<string>();
 
+type ReviewPostMode = 'auto' | 'manual' | 'disabled';
+
+function getFlowPostMode(flow: any): ReviewPostMode {
+  const rawValue = flow?.get?.('postMode');
+  const value = rawValue && typeof rawValue === 'object' && 'value' in rawValue ? rawValue.value : rawValue;
+  const normalized = String(value || 'manual')
+    .trim()
+    .toLowerCase()
+    .replace(/[\s-]+/g, '_');
+
+  if (['auto', 'auto_post', 'autopost', 'auto_post_to_mr'].includes(normalized)) return 'auto';
+  if (['disabled', 'disable', 'do_not_post', 'dont_post', 'none', 'skip', 'skipped'].includes(normalized)) {
+    return 'disabled';
+  }
+  return 'manual';
+}
+
+function getInitialPostStatus(flow: any, targetType: string): string {
+  const postMode = getFlowPostMode(flow);
+  if (postMode === 'disabled') return 'skipped';
+  if (postMode === 'auto' && targetType !== 'mr') return 'skipped';
+  return 'pending_approval';
+}
+
 function warnInvalidBranchFilter(filter: string, reason: string) {
   if (loggedBadFilters.has(filter)) return;
   loggedBadFilters.add(filter);
@@ -717,11 +905,10 @@ function throwHttp(status: number, message: string): never {
 }
 
 /**
- * Reviews are launched via `setImmediate` and tracked entirely in process
- * memory. When the app restarts mid-run, the in-memory promise dies but the
- * DB record stays in `status='running'` indefinitely. On startup we sweep
- * any `running` review whose `startedAt` is older than the in-process
- * timeout (5 min) plus a safety margin and mark it as failed.
+ * Review execution is delegated to the distributed event queue. When a worker
+ * restarts mid-run, the DB record can stay in `status='running'` indefinitely.
+ * On startup we sweep any `running` review whose `startedAt` is older than the
+ * in-process timeout (5 min) plus a safety margin and mark it as failed.
  *
  * The cutoff is intentionally larger than the runtime timeout so concurrent
  * reviews running on a *different* node in an HA cluster aren't clobbered.
@@ -732,13 +919,11 @@ export async function recoverStuckReviews(app: Application): Promise<number> {
   try {
     const reviewsRepo = app.db.getRepository('gitCodeReviews');
     const cutoff = new Date(Date.now() - STUCK_REVIEW_CUTOFF_MS);
-    // Sweep both `running` (interrupted mid-execution) and `pending`
-    // (interrupted between record creation and runReview's first update).
-    // Both have `startedAt` stamped at trigger time so the cutoff applies
-    // consistently.
+    // Pending rows may be legitimately waiting in Redis, so only sweep reviews
+    // that were actually picked up by a worker.
     const stuck = await reviewsRepo.find({
       filter: {
-        status: { $in: ['running', 'pending'] },
+        status: 'running',
         startedAt: { $lt: cutoff },
       },
     });

package/src/server/ai-tools.ts

@@ -90,6 +90,7 @@ export function registerGitReviewAiTools(app: Application) {
       app: ctx.app,
       db: ctx.db,
       action: { params },
+      request: { ...(ctx.request || {}), body: ctx.request?.body || {} },
       throw: (status: number, message: string) => {
         const err: any = new Error(message);
         err.status = status;

package/src/server/collections/gitCodeReviews.ts

@@ -136,6 +136,7 @@ export default defineCollection({
           { value: 'pending_approval', label: 'Pending Approval' },
           { value: 'approved', label: 'Approved' },
           { value: 'posted', label: 'Posted' },
+          { value: 'post_failed', label: 'Post Failed' },
           { value: 'skipped', label: 'Skipped' },
           { value: 'rejected', label: 'Rejected' },
         ],