hungry-ghost-hive 0.40.3 → 0.41.1

package/dist/cli/commands/manager/index.js

@@ -16,6 +16,7 @@ import { createLog } from '../../../db/queries/logs.js';
 import { getAllPendingMessages, markMessagesRead, } from '../../../db/queries/messages.js';
 import { backfillGithubPrNumbers, createPullRequest, getMergeQueue, getOpenPullRequestsByStory, getPullRequestsByStatus, updatePullRequest, } from '../../../db/queries/pull-requests.js';
 import { getStoriesByStatus, getStoryById, updateStory } from '../../../db/queries/stories.js';
+import { getPullRequestComments, getPullRequestReviews } from '../../../git/github.js';
 import { Scheduler } from '../../../orchestrator/scheduler.js';
 import { AgentState } from '../../../state-detectors/types.js';
 import { captureTmuxPane, getHiveSessions, isManagerRunning, isTmuxSessionRunning, killTmuxSession, sendToTmuxSession, spawnTmuxSession, stopManager as stopManagerSession, } from '../../../tmux/manager.js';
@@ -688,6 +689,8 @@ async function managerCheck(root, config, clusterRuntime, verbose = false) {
     await batchMarkMessagesRead(ctx);
     verboseLogCtx(ctx, 'Step: notify QA about queued PRs');
     await notifyQAOfQueuedPRs(ctx);
+    verboseLogCtx(ctx, 'Step: auto-reject comment-only reviews');
+    await autoRejectCommentOnlyReviews(ctx);
     verboseLogCtx(ctx, 'Step: handle rejected PRs');
     await handleRejectedPRs(ctx);
     verboseLogCtx(ctx, 'Step: recover unassigned qa_failed stories');
@@ -1160,8 +1163,26 @@ async function recoverStaleReviewingPRs(ctx) {
             const parsed = JSON.parse(result.stdout);
             const state = parsed.state?.toUpperCase();
             const url = parsed.url || null;
-            if (state === 'OPEN')
+            if (state === 'OPEN') {
+                // PR is still open on GitHub but stale in 'reviewing' — the QA agent
+                // may have missed the original nudge. Re-nudge if QA agent is idle.
+                if (candidate.reviewedBy) {
+                    const qaAgent = ctx.agentsBySessionName.get(candidate.reviewedBy);
+                    if (qaAgent && qaAgent.status === 'idle') {
+                        const githubLine = candidate.repoSlug
+                            ? `\n# GitHub: https://github.com/${candidate.repoSlug}/pull/${candidate.githubPrNumber}`
+                            : '';
+                        await sendManagerNudge(ctx, candidate.reviewedBy, `# [REMINDER] You are assigned PR review ${candidate.id} (${candidate.storyId || 'no-story'}).${githubLine}
+# This PR has been waiting for review. Execute now:
+#   hive pr show ${candidate.id}
+#   hive pr approve ${candidate.id}
+# or reject:
+#   hive pr reject ${candidate.id} -r "reason"`);
+                        verboseLogCtx(ctx, `recoverStaleReviewingPRs: re-nudged idle QA ${candidate.reviewedBy} for stale pr=${candidate.id}`);
+                    }
+                }
                 continue;
+            }
             if (state === 'MERGED') {
                 mergedResults.push({
                     candidate,
@@ -1412,9 +1433,16 @@ async function scanAgentSessions(ctx) {
     for (const session of ctx.hiveSessions) {
         if (session.name === 'hive-manager')
             continue;
-        activeSessionNames.add(session.name);
         const agent = ctx.agentsBySessionName.get(session.name);
-        const agentCliTool = (agent?.cli_tool || 'claude');
+        // Skip sessions not registered in our DB (cross-project sessions).
+        // This prevents escalation noise from sessions belonging to other
+        // teams/projects sharing the same tmux server.
+        if (!agent) {
+            verboseLogCtx(ctx, `Skipping ${session.name}: no agent registered in DB (cross-project)`);
+            continue;
+        }
+        activeSessionNames.add(session.name);
+        const agentCliTool = (agent.cli_tool || 'claude');
         const safetyMode = getAgentSafetyMode(ctx.config, agent);
         verboseLogCtx(ctx, `Agent check: ${session.name} (cli=${agentCliTool}, safety=${safetyMode}, story=${agent?.current_story_id || '-'})`);
         // Forward unread messages (tmux I/O, no lock needed)
@@ -1650,6 +1678,146 @@ async function notifyQAOfQueuedPRs(ctx) {
         }
     }
 }
+/**
+ * Auto-reject PRs where the QA agent posted review comments/feedback on GitHub
+ * but never formally approved or rejected via `hive pr approve/reject`.
+ *
+ * Detection: PR is in 'reviewing' status, the assigned QA agent is idle,
+ * and there are GitHub comments or CHANGES_REQUESTED reviews on the PR.
+ *
+ * Action: Auto-reject the PR with the QA's feedback as the rejection reason,
+ * which triggers the standard qa_failed flow back to the developer agent.
+ */
+export async function autoRejectCommentOnlyReviews(ctx) {
+    // Phase 1: Identify reviewing PRs with idle QA agents (brief lock)
+    const candidates = await ctx.withDb(async (db) => {
+        const reviewingPRs = getPullRequestsByStatus(db.db, 'reviewing').filter(pr => pr.github_pr_number && pr.team_id && pr.reviewed_by);
+        verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: reviewingWithQA=${reviewingPRs.length}`);
+        if (reviewingPRs.length === 0)
+            return [];
+        // Only consider PRs whose QA agent is idle (finished reviewing but didn't approve/reject)
+        const idlePRs = reviewingPRs.filter(pr => {
+            const qaAgent = ctx.agentsBySessionName.get(pr.reviewed_by);
+            if (!qaAgent)
+                return false;
+            // Check if the QA agent is idle or if their session shows idle state
+            const qaState = agentStates.get(pr.reviewed_by);
+            return qaAgent.status === 'idle' || qaState?.lastState === AgentState.IDLE_AT_PROMPT;
+        });
+        verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: idleQACandidates=${idlePRs.length}`);
+        if (idlePRs.length === 0)
+            return [];
+        const { getAllTeams } = await import('../../../db/queries/teams.js');
+        const teams = getAllTeams(db.db);
+        const teamsById = new Map(teams.map(team => [team.id, team]));
+        return idlePRs
+            .map(pr => {
+            const team = teamsById.get(pr.team_id);
+            if (!team?.repo_path)
+                return null;
+            return {
+                id: pr.id,
+                storyId: pr.story_id,
+                teamId: pr.team_id,
+                branchName: pr.branch_name,
+                githubPrNumber: pr.github_pr_number,
+                reviewedBy: pr.reviewed_by,
+                submittedBy: pr.submitted_by,
+                repoDir: `${ctx.root}/${team.repo_path}`,
+            };
+        })
+            .filter(Boolean);
+    });
+    if (candidates.length === 0)
+        return;
+    // Phase 2: Check GitHub for comments/reviews on each candidate (no lock)
+    const toReject = [];
+    for (const candidate of candidates) {
+        try {
+            // Fetch both reviews and comments from GitHub
+            const [reviews, comments] = await Promise.all([
+                getPullRequestReviews(candidate.repoDir, candidate.githubPrNumber).catch(() => []),
+                getPullRequestComments(candidate.repoDir, candidate.githubPrNumber).catch(() => []),
+            ]);
+            // If there's a formal APPROVED review, skip (QA approved via GitHub directly)
+            const hasApproval = reviews.some(r => r.state === 'APPROVED');
+            if (hasApproval) {
+                verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: pr=${candidate.id} has GitHub approval, skipping`);
+                continue;
+            }
+            // Check for CHANGES_REQUESTED reviews
+            const changesRequested = reviews.filter(r => r.state === 'CHANGES_REQUESTED');
+            // Check for substantive issue comments (filter out bot noise and very short comments)
+            const substantiveComments = comments.filter(c => {
+                if (c.body.length < 20)
+                    return false;
+                // Skip known bot comments (Ellipsis, etc.)
+                if (c.body.includes('Looks good to me') && c.body.length < 100)
+                    return false;
+                return true;
+            });
+            // If there are review feedback items, auto-reject
+            if (changesRequested.length > 0 || substantiveComments.length > 0) {
+                // Build rejection reason from the feedback
+                const feedbackParts = [];
+                for (const review of changesRequested) {
+                    if (review.body)
+                        feedbackParts.push(review.body);
+                }
+                for (const comment of substantiveComments) {
+                    feedbackParts.push(comment.body);
+                }
+                const reason = feedbackParts.length > 0
+                    ? feedbackParts.join('\n---\n').slice(0, 2000)
+                    : 'QA posted review feedback on GitHub without formal approval. See PR comments.';
+                toReject.push({ candidate, reason });
+                verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: pr=${candidate.id} has ${changesRequested.length} changes_requested + ${substantiveComments.length} comments, will auto-reject`);
+            }
+        }
+        catch (err) {
+            verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: skip pr=${candidate.id} github_check_failed=${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (toReject.length === 0)
+        return;
+    // Phase 3: Reject PRs in DB (brief lock)
+    await ctx.withDb(async (db) => {
+        for (const { candidate, reason } of toReject) {
+            await withTransaction(db.db, () => {
+                updatePullRequest(db.db, candidate.id, {
+                    status: 'rejected',
+                    reviewNotes: reason,
+                });
+                if (candidate.storyId) {
+                    updateStory(db.db, candidate.storyId, { status: 'qa_failed' });
+                }
+                createLog(db.db, {
+                    agentId: 'manager',
+                    eventType: 'PR_REJECTED',
+                    message: `Auto-rejected PR ${candidate.id}: QA posted review comments without formal approve/reject`,
+                    storyId: candidate.storyId || undefined,
+                    metadata: { pr_id: candidate.id, auto_rejected: true },
+                });
+            }, () => db.save());
+            console.log(chalk.yellow(`  Auto-rejected PR ${candidate.id} (story: ${candidate.storyId || '-'}): QA left review comments without approving`));
+        }
+    });
+    // Phase 4: Notify developer agents via tmux (no lock)
+    for (const { candidate, reason } of toReject) {
+        if (candidate.submittedBy) {
+            const devSession = ctx.hiveSessions.find(s => s.name === candidate.submittedBy);
+            if (devSession) {
+                await sendManagerNudge(ctx, devSession.name, `# ⚠️ PR AUTO-REJECTED - QA REVIEW FEEDBACK ⚠️
+# Story: ${candidate.storyId || 'Unknown'}
+# QA agent (${candidate.reviewedBy}) posted review feedback without formally approving.
+# Feedback:
+# ${reason.split('\n').slice(0, 10).join('\n# ')}
+#
+# Fix the issues and resubmit: hive pr submit -b ${candidate.branchName} -s ${candidate.storyId || 'STORY-ID'} --from ${devSession.name}`);
+            }
+        }
+    }
+}
 async function handleRejectedPRs(ctx) {
     // Phase 1: Read rejected PRs and update DB (brief lock)
     const rejectedPRData = await ctx.withDb(async (db) => {