@gethmy/agent 1.0.9 → 1.1.1

package/dist/review-completion.js

@@ -1,66 +1,132 @@
 import { addLabelByName, moveCardToColumn } from "./board-helpers.js";
+import { buildTokenPayload } from "./completion.js";
 import { createPullRequest, detectGitProvider, pushBranch } from "./git-pr.js";
 import { log } from "./log.js";
+import { NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR, } from "./types.js";
 import { cleanupWorktree } from "./worktree.js";
 const TAG = "review-completion";
 const MAX_FINDINGS = 10;
 const REVIEW_MARKER = "---\n**Review:";
+/**
+ * Extract structured fields from a parsed JSON object into a ReviewResult.
+ */
+function extractResult(parsed) {
+    const verdict = parsed.verdict === "approved" || parsed.verdict === "rejected"
+        ? parsed.verdict
+        : "rejected";
+    const findings = Array.isArray(parsed.findings)
+        ? parsed.findings
+            .filter((f) => typeof f === "object" && f !== null && "title" in f)
+            .map((f) => ({
+            severity: f.severity === "critical"
+                ? "critical"
+                : f.severity === "minor"
+                    ? "minor"
+                    : "major",
+            title: String(f.title ?? "Untitled finding"),
+            description: String(f.description ?? ""),
+            category: f.category ? String(f.category) : undefined,
+            location: f.location ? String(f.location) : undefined,
+        }))
+        : [];
+    const scopeCheck = parsed.scopeCheck &&
+        typeof parsed.scopeCheck === "object" &&
+        "status" in parsed.scopeCheck
+        ? {
+            status: ["clean", "drift", "missing"].includes(parsed.scopeCheck.status)
+                ? parsed.scopeCheck.status
+                : "clean",
+            notes: parsed.scopeCheck.notes
+                ? String(parsed.scopeCheck.notes)
+                : undefined,
+        }
+        : undefined;
+    return {
+        verdict,
+        summary: String(parsed.summary ?? "").slice(0, 2000),
+        scopeCheck,
+        findings,
+    };
+}
 /**
  * Parse Claude's review output into a structured ReviewResult.
- * Looks for a JSON block in the output.
+ *
+ * Tries multiple extraction strategies in order:
+ * 1. ```json ... ``` fenced block (what the prompt asks for)
+ * 2. Any top-level JSON object containing a "verdict" key (last-wins)
+ * 3. Regex for a bare `"verdict": "approved|rejected"` anywhere — lossy
+ *    but keeps the pipeline moving
+ * 4. Falls back to verdict: "error" — keeps card in Review instead of
+ *    bouncing it to To Do for a parse failure that isn't a code quality signal.
  */
 export function parseReviewOutput(stdout) {
-    // Try to find a JSON block in the output
-    const jsonMatch = stdout.match(/```json\s*([\s\S]*?)```/);
-    const rawJson = jsonMatch?.[1]?.trim() ?? stdout.trim();
-    try {
-        const parsed = JSON.parse(rawJson);
-        const verdict = parsed.verdict === "approved" || parsed.verdict === "rejected"
-            ? parsed.verdict
-            : "rejected";
-        const findings = Array.isArray(parsed.findings)
-            ? parsed.findings
-                .filter((f) => typeof f === "object" && f !== null && "title" in f)
-                .map((f) => ({
-                severity: f.severity === "critical"
-                    ? "critical"
-                    : f.severity === "minor"
-                        ? "minor"
-                        : "major",
-                title: String(f.title ?? "Untitled finding"),
-                description: String(f.description ?? ""),
-                category: f.category ? String(f.category) : undefined,
-                location: f.location ? String(f.location) : undefined,
-            }))
-            : [];
-        const scopeCheck = parsed.scopeCheck &&
-            typeof parsed.scopeCheck === "object" &&
-            "status" in parsed.scopeCheck
-            ? {
-                status: ["clean", "drift", "missing"].includes(parsed.scopeCheck.status)
-                    ? parsed.scopeCheck.status
-                    : "clean",
-                notes: parsed.scopeCheck.notes
-                    ? String(parsed.scopeCheck.notes)
-                    : undefined,
+    // Strategy 1: fenced ```json block (greedy-last to handle multiple blocks)
+    const fencedBlocks = [...stdout.matchAll(/```json\s*([\s\S]*?)```/g)];
+    for (let i = fencedBlocks.length - 1; i >= 0; i--) {
+        const raw = fencedBlocks[i][1].trim();
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object" && "verdict" in parsed) {
+                log.debug(TAG, "Parsed review output from fenced JSON block");
+                return extractResult(parsed);
             }
-            : undefined;
-        return {
-            verdict,
-            summary: String(parsed.summary ?? "").slice(0, 2000),
-            scopeCheck,
-            findings,
-        };
+        }
+        catch {
+            // try next block
+        }
     }
-    catch {
-        // If we can't parse JSON, treat as rejection with the raw output as summary
-        log.warn(TAG, "Failed to parse review JSON output, treating as rejection");
+    // Strategy 2: scan every top-level { ... } block and take the last one
+    // that parses AND contains "verdict". This handles cases where the output
+    // has multiple stray braces before the real JSON object.
+    const candidates = [];
+    let depth = 0;
+    let start = -1;
+    for (let i = 0; i < stdout.length; i++) {
+        const ch = stdout[i];
+        if (ch === "{") {
+            if (depth === 0)
+                start = i;
+            depth++;
+        }
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0 && start !== -1) {
+                candidates.push(stdout.slice(start, i + 1));
+                start = -1;
+            }
+        }
+    }
+    for (let i = candidates.length - 1; i >= 0; i--) {
+        try {
+            const parsed = JSON.parse(candidates[i]);
+            if (parsed && typeof parsed === "object" && "verdict" in parsed) {
+                log.debug(TAG, "Parsed review output from raw JSON object");
+                return extractResult(parsed);
+            }
+        }
+        catch {
+            // try next
+        }
+    }
+    // Strategy 3: regex for a bare verdict declaration anywhere in the output.
+    // Loses findings/summary but preserves approve/reject signal so the pipeline
+    // can make progress instead of looping on "error".
+    const verdictMatch = stdout.match(/"verdict"\s*:\s*"(approved|rejected)"/i);
+    if (verdictMatch) {
+        log.warn(TAG, `Parsed verdict via regex fallback — findings lost (${verdictMatch[1]})`);
         return {
-            verdict: "rejected",
-            summary: stdout.slice(0, 500),
+            verdict: verdictMatch[1].toLowerCase(),
+            summary: "Parsed via regex fallback — original JSON was malformed. Check run log.",
             findings: [],
         };
     }
+    // Strategy 4: nothing parseable — return error verdict so the card stays in Review
+    log.warn(TAG, "Failed to parse review JSON output — returning error verdict (card stays in Review)");
+    return {
+        verdict: "error",
+        summary: stdout.slice(0, 500),
+        findings: [],
+    };
 }
 /**
  * Get the current review cycle count from card description.
@@ -97,7 +163,7 @@ function stripReviewSummary(description) {
  * Handles approved/rejected verdicts, creates subtasks for findings,
  * and moves the card to the appropriate column.
  */
-export async function runReviewCompletion(client, card, result, config, worktreePath, branchName) {
+export async function runReviewCompletion(client, card, result, config, worktreePath, branchName, sessionStats) {
     // Re-fetch card for fresh description (avoids stale data from enqueue time)
     let freshDesc;
     try {
@@ -109,6 +175,42 @@ export async function runReviewCompletion(client, card, result, config, worktree
     }
     const currentCycle = getReviewCycle(freshDesc) + 1;
     const maxCycles = config.review.maxReviewCycles;
+    if (result.verdict === "error") {
+        // Parse failure — not a code quality signal. Keep card in Review and
+        // add the "Need Review" label so reconcile stops re-enqueueing it.
+        // Without the label, the reconcile loop would respawn the review every
+        // cycle and burn budget on the same unparseable output (see #122).
+        log.warn(TAG, `#${card.short_id} review output unparseable — labelling "${NEED_REVIEW_LABEL}" for manual inspection`);
+        try {
+            await addLabelByName(client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
+        }
+        catch (err) {
+            log.warn(TAG, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
+        }
+        if (config.review.postFindings) {
+            const baseDesc = stripReviewSummary(freshDesc);
+            const summary = [
+                `\n\n${REVIEW_MARKER} Parse error**`,
+                '\nThe review agent\'s output could not be parsed. Card stays in Review with the "Need Review" label — check the run log in ~/.harmony-mcp/runs/ for diagnosis.',
+                result.summary ? `\n\nRaw output (truncated):\n${result.summary}` : "",
+            ].join("");
+            try {
+                await client.updateCard(card.id, { description: baseDesc + summary });
+            }
+            catch (err) {
+                log.error(TAG, `Failed to update description: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+        await client.endAgentSession(card.id, {
+            status: "paused",
+            ...buildTokenPayload(sessionStats),
+        });
+        // Cleanup worktree but do NOT move the card
+        if (branchName) {
+            cleanupWorktree(worktreePath, branchName);
+        }
+        return;
+    }
     if (result.verdict === "approved") {
         // Ensure branch is pushed (skip in local mode — no branch to push)
         let prUrl = null;
@@ -150,6 +252,7 @@ export async function runReviewCompletion(client, card, result, config, worktree
         await client.endAgentSession(card.id, {
             status: "completed",
             progressPercent: 100,
+            ...buildTokenPayload(sessionStats),
         });
         log.info(TAG, `#${card.short_id} approved${prUrl ? ` — PR: ${prUrl}` : ""} — labeled "${config.review.approvedLabel}"`);
     }
@@ -181,7 +284,10 @@ export async function runReviewCompletion(client, card, result, config, worktree
             catch (err) {
                 log.error(TAG, `Failed to update description: ${err instanceof Error ? err.message : err}`);
             }
-            await client.endAgentSession(card.id, { status: "completed" });
+            await client.endAgentSession(card.id, {
+                status: "completed",
+                ...buildTokenPayload(sessionStats),
+            });
             if (branchName) {
                 cleanupWorktree(worktreePath, branchName);
             }
@@ -243,7 +349,10 @@ export async function runReviewCompletion(client, card, result, config, worktree
         }
         // Move back to failColumn (To Do) for re-implementation
         await moveCardToColumn(client, card, config.review.failColumn);
-        await client.endAgentSession(card.id, { status: "paused" });
+        await client.endAgentSession(card.id, {
+            status: "paused",
+            ...buildTokenPayload(sessionStats),
+        });
         log.info(TAG, `#${card.short_id} rejected (cycle ${currentCycle}/${maxCycles}) — moved to "${config.review.failColumn}"`);
     }
     // Cleanup worktree (skip in local mode — no worktree to clean)

package/dist/review-worker.d.ts

@@ -1,10 +1,12 @@
 import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
 import type { Card, Column, Label, Subtask } from "@harmony/shared";
+import { type StateStore } from "./state-store.js";
 import { type AgentConfig, type WorkerState } from "./types.js";
 export declare class ReviewWorker {
     private config;
     private client;
     private onDone;
+    private stateStore;
     id: number;
     state: WorkerState;
     cardId: string | null;
@@ -14,9 +16,15 @@ export declare class ReviewWorker {
     private process;
     private devServerProcess;
     private timeoutTimer;
+    private heartbeatTimer;
     private progressTracker;
+    private lastSessionStats;
     private aborted;
-    constructor(id: number, config: AgentConfig, client: HarmonyApiClient, _userEmail: string, onDone: (worker: ReviewWorker) => void);
+    private runId;
+    constructor(id: number, config: AgentConfig, client: HarmonyApiClient, _userEmail: string, onDone: (worker: ReviewWorker) => void, stateStore: StateStore);
+    private startHeartbeat;
+    private stopHeartbeat;
+    private recordPhase;
     get tag(): string;
     get isIdle(): boolean;
     private get reviewPort();
@@ -39,7 +47,6 @@ export declare class ReviewWorker {
      */
     cancel(): Promise<void>;
     private spawnClaude;
-    private waitForExit;
     private killDevServer;
     private resolveLocalChanges;
     private cleanup;