@gethmy/agent 1.6.0 → 1.7.0

package/README.md

@@ -36,11 +36,12 @@ npx @gethmy/mcp setup
 ```jsonc
 {
   "agent": {
-    "poolSize": 1,
+    "poolSize": 3,
     "pickupColumns": ["To Do"],
     "claude": { "model": "opus", "reviewModel": "sonnet" },
     "review": {
       "enabled": true,
+      "poolSize": 2,
       "pickupColumns": ["Review"],
       "moveToColumn": "Done",
       "failColumn": "To Do"

package/dist/budget.js

@@ -103,9 +103,18 @@ export class BudgetGuard {
         log.warn(TAG, `#${card.short_id} DLQ'd — ${reason}: ${detail}`);
     }
 }
-const DLQ_MARKER = "---\n**Agent DLQ**";
+const DLQ_FENCE_START = "<!-- agent-dlq:start -->";
+const DLQ_FENCE_END = "<!-- agent-dlq:end -->";
+// Legacy marker — pre-fence DLQ blocks written before 2026-05-23. Strip path
+// only; new blocks always emit the fenced form.
+const LEGACY_DLQ_MARKER = "---\n**Agent DLQ**";
 function buildDlqDescriptionBlock(reason, detail, failures) {
-    const lines = [DLQ_MARKER, `Cap hit: ${reason} — ${detail}`];
+    const lines = [
+        DLQ_FENCE_START,
+        "---",
+        "**Agent DLQ**",
+        `Cap hit: ${reason} — ${detail}`,
+    ];
     if (failures.length > 0) {
         lines.push("", "Recent failures:");
         for (const f of failures) {
@@ -120,13 +129,32 @@ function buildDlqDescriptionBlock(reason, detail, failures) {
     else {
         lines.push("", "_No prior failure summaries recorded._");
     }
+    lines.push(DLQ_FENCE_END);
     return lines.join("\n");
 }
 function stripDlqBlock(description) {
-    const idx = description.indexOf(DLQ_MARKER);
-    if (idx < 0)
-        return description.trimEnd();
-    return description.slice(0, idx).trimEnd();
+    const start = description.indexOf(DLQ_FENCE_START);
+    if (start >= 0) {
+        const end = description.indexOf(DLQ_FENCE_END, start);
+        if (end < 0) {
+            // Malformed: opening fence with no closer. Treat the rest of the
+            // description as the block — safer than preserving an orphan fence.
+            return description.slice(0, start).trimEnd();
+        }
+        const prefix = description.slice(0, start).trimEnd();
+        const suffix = description
+            .slice(end + DLQ_FENCE_END.length)
+            .replace(/^\s+/, "");
+        if (prefix && suffix)
+            return `${prefix}\n\n${suffix}`;
+        return prefix || suffix;
+    }
+    // Legacy unfenced block — match the original behavior (no suffix to
+    // preserve, since the legacy emitter always wrote to end-of-description).
+    const legacy = description.indexOf(LEGACY_DLQ_MARKER);
+    if (legacy >= 0)
+        return description.slice(0, legacy).trimEnd();
+    return description.trimEnd();
 }
 function formatCents(cents) {
     return `$${(cents / 100).toFixed(2)}`;

package/dist/completion.d.ts

@@ -29,4 +29,4 @@ export declare function buildTokenPayload(stats?: SessionStats | null): {
 /**
  * Post-work pipeline: push branch, create PR, move card, post summary.
  */
-export declare function runCompletion(client: HarmonyApiClient, card: Card, branchName: string, worktreePath: string, config: AgentConfig, workerId?: number, sessionStats?: SessionStats, workspaceId?: string, agentSessionId?: string | null, stateStore?: StateStore): Promise<void>;
+export declare function runCompletion(client: HarmonyApiClient, card: Card, branchName: string, worktreePath: string, config: AgentConfig, workerId: number, sessionStats: SessionStats | undefined, workspaceId: string | undefined, agentSessionId: string | null | undefined, stateStore: StateStore): Promise<void>;

package/dist/completion.js

@@ -29,7 +29,7 @@ export function buildTokenPayload(stats) {
 /**
  * Post-work pipeline: push branch, create PR, move card, post summary.
  */
-export async function runCompletion(client, card, branchName, worktreePath, config, workerId = 0, sessionStats, workspaceId, agentSessionId, stateStore) {
+export async function runCompletion(client, card, branchName, worktreePath, config, workerId, sessionStats, workspaceId, agentSessionId, stateStore) {
     // Hoisted so the episode write hook can read final verification state.
     let verificationResult = {
         passed: true,
@@ -54,16 +54,25 @@ export async function runCompletion(client, card, branchName, worktreePath, conf
     // under `agent-attempts/*` for `failedAttemptRetentionDays`. Without this
     // ordering, verify failures used to orphan commits in a deleted worktree —
     // recoverable only via `git reflog`.
+    //
+    // `lastPushedSha` tracks the most recent commit we successfully pushed so
+    // later push points (post-fix, post-fail) can skip when HEAD hasn't moved.
     log.info(TAG, `Pushing branch ${branchName} (pre-verify)...`);
+    let lastPushedSha = null;
     try {
         pushBranch(branchName, worktreePath);
+        lastPushedSha = readHeadSha(worktreePath);
     }
     catch (err) {
         // Push failure shouldn't prevent verification from running, but the
         // safety guarantee is gone — surface it loudly so the operator notices.
         log.error(TAG, `pre-verify push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
     }
-    const recoveryUrl = getBranchWebUrl(branchName, worktreePath);
+    // Only surface a recovery URL when the push actually landed — otherwise
+    // the link points at a ref that doesn't exist on origin.
+    const recoveryUrl = lastPushedSha
+        ? getBranchWebUrl(branchName, worktreePath)
+        : null;
     // 2. Verification gate
     if (config.verification.enabled) {
         await client.updateAgentProgress(card.id, {
@@ -91,12 +100,18 @@ export async function runCompletion(client, card, branchName, worktreePath, conf
                 autoFixAttempts = attempt + 1;
                 if (result.passed) {
                     log.info(TAG, `Auto-fix succeeded on attempt ${attempt + 1}`);
-                    // Push again so the auto-fix commit is also durable on origin.
-                    try {
-                        pushBranch(branchName, worktreePath);
-                    }
-                    catch (err) {
-                        log.warn(TAG, `post-fix push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
+                    // Push again so any auto-fix commits are durable on origin. Skip
+                    // when HEAD hasn't moved since the last successful push — autofix
+                    // can pass without producing new commits.
+                    const sha = readHeadSha(worktreePath);
+                    if (sha && sha !== lastPushedSha) {
+                        try {
+                            pushBranch(branchName, worktreePath);
+                            lastPushedSha = sha;
+                        }
+                        catch (err) {
+                            log.warn(TAG, `post-fix push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
+                        }
                     }
                     break;
                 }
@@ -106,16 +121,22 @@ export async function runCompletion(client, card, branchName, worktreePath, conf
         if (!result.passed) {
             log.warn(TAG, `Verification failed for #${card.short_id} — reporting findings`);
             // Push the latest tip (including any auto-fix attempts) so the
-            // failed branch on origin reflects what verify saw.
-            try {
-                pushBranch(branchName, worktreePath);
-            }
-            catch (err) {
-                log.warn(TAG, `post-fail push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
+            // failed branch on origin reflects what verify saw. Skip when HEAD
+            // hasn't advanced since the last successful push — common when
+            // every auto-fix attempt produced no new commits.
+            const failSha = readHeadSha(worktreePath);
+            if (failSha && failSha !== lastPushedSha) {
+                try {
+                    pushBranch(branchName, worktreePath);
+                    lastPushedSha = failSha;
+                }
+                catch (err) {
+                    log.warn(TAG, `post-fail push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
+                }
             }
             const failureSummary = buildVerificationFailureSummary(result, autoFixAttempts);
             try {
-                await stateStore?.recordFailureSummary(card.id, {
+                await stateStore.recordFailureSummary(card.id, {
                     summary: failureSummary,
                     reason: "verification",
                     recoveryBranch: branchName,
@@ -124,10 +145,10 @@ export async function runCompletion(client, card, branchName, worktreePath, conf
             catch (err) {
                 log.debug(TAG, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
             }
-            await reportFindings(client, card.id, result, {
-                branchName,
-                branchUrl: recoveryUrl,
-            });
+            // Only attach recovery instructions when the branch actually exists
+            // on origin — otherwise the `git fetch && git checkout` command we'd
+            // surface would fail for the user.
+            await reportFindings(client, card.id, result, lastPushedSha ? { branchName, branchUrl: recoveryUrl } : null);
             await moveCardToColumn(client, card, config.verification.failColumn);
             await client.endAgentSession(card.id, {
                 status: "failed",
@@ -204,6 +225,17 @@ function buildVerificationFailureSummary(result, autoFixAttempts) {
     const tail = autoFixAttempts > 0 ? ` after ${autoFixAttempts} auto-fix attempt(s)` : "";
     return `${head}${tail}`;
 }
+function readHeadSha(worktreePath) {
+    try {
+        return execFileSync("git", ["rev-parse", "HEAD"], {
+            cwd: worktreePath,
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
 function checkHasCommits(worktreePath, baseBranch) {
     try {
         const count = execFileSync("git", ["rev-list", "--count", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();

package/dist/git-pr.js

@@ -158,7 +158,28 @@ export function remoteBranchExists(branchName, cwd) {
 export function pushBranch(branchName, cwd) {
     if (remoteBranchExists(branchName, cwd)) {
         log.info(TAG, `Remote branch ${branchName} exists (rework), force-pushing`);
-        execFileSync("git", ["push", "--force-with-lease", "-u", "origin", branchName], { cwd, stdio: "pipe" });
+        // Resolve the remote tip explicitly so the lease anchors to a known SHA.
+        // Bare `--force-with-lease` only checks against the local tracking ref,
+        // which can be stale if it was never fetched in this worktree — that
+        // lets a concurrent update slip through. Fetch + pin the expected SHA.
+        let expectedSha = null;
+        try {
+            execFileSync("git", ["fetch", "origin", branchName], {
+                cwd,
+                stdio: "pipe",
+            });
+            expectedSha = execFileSync("git", ["rev-parse", `refs/remotes/origin/${branchName}`], { cwd, encoding: "utf-8" }).trim();
+        }
+        catch (err) {
+            log.warn(TAG, `could not resolve remote tip for ${branchName}, falling back to weak lease: ${err instanceof Error ? err.message : err}`);
+        }
+        const lease = expectedSha
+            ? `--force-with-lease=refs/heads/${branchName}:${expectedSha}`
+            : "--force-with-lease";
+        execFileSync("git", ["push", lease, "-u", "origin", branchName], {
+            cwd,
+            stdio: "pipe",
+        });
     }
     else {
         execFileSync("git", ["push", "-u", "origin", branchName], {

package/dist/index.js

@@ -267,7 +267,9 @@ export async function main() {
     }
     // Banner check lines for service intervals + pool. Compose into one
     // line each so the banner stays compact.
-    const reviewCount = config.agent.review.enabled ? 1 : 0;
+    const reviewCount = config.agent.review.enabled
+        ? config.agent.review.poolSize
+        : 0;
     banner.check(`Pool: ${config.agent.poolSize} impl${reviewCount > 0 ? ` + ${reviewCount} review` : ""}`);
     const services = [
         `Heartbeat ${config.agent.timing.reconcileIntervalMs / 1000}s`,

package/dist/pool.js

@@ -23,12 +23,16 @@ export class Pool {
                 this.tryDispatchFor(this.implWorkers, this.implQueue, "impl");
             }, workspaceId, projectId, stateStore));
         }
-        // Create review worker(s) — 1 review worker per pool
+        // Create review workers. IDs offset by `config.poolSize` so impl and
+        // review worker IDs never collide (verification + review ports both
+        // derive from the worker ID, so collision would mean port collision).
         if (config.review.enabled) {
-            const reviewWorkerId = config.poolSize; // offset to avoid ID collision
-            this.reviewWorkers.push(new ReviewWorker(reviewWorkerId, config, client, userEmail, () => {
-                this.tryDispatchFor(this.reviewWorkers, this.reviewQueue, "review");
-            }, stateStore, workspaceId, projectId));
+            for (let i = 0; i < config.review.poolSize; i++) {
+                const reviewWorkerId = config.poolSize + i;
+                this.reviewWorkers.push(new ReviewWorker(reviewWorkerId, config, client, userEmail, () => {
+                    this.tryDispatchFor(this.reviewWorkers, this.reviewQueue, "review");
+                }, stateStore, workspaceId, projectId));
+            }
         }
     }
     /**

package/dist/review-completion.d.ts

@@ -37,4 +37,4 @@ export declare function parseReviewOutput(stdout: string): ReviewResult;
  * Handles approved/rejected verdicts, creates subtasks for findings,
  * and moves the card to the appropriate column.
  */
-export declare function runReviewCompletion(client: HarmonyApiClient, card: Card, result: ReviewResult, config: AgentConfig, worktreePath: string, branchName: string | null, sessionStats?: SessionStats | null, runLogPath?: string | null, workspaceId?: string, agentSessionId?: string | null, stateStore?: StateStore): Promise<void>;
+export declare function runReviewCompletion(client: HarmonyApiClient, card: Card, result: ReviewResult, config: AgentConfig, worktreePath: string, branchName: string | null, sessionStats: SessionStats | null | undefined, runLogPath: string | null | undefined, workspaceId: string | undefined, agentSessionId: string | null | undefined, stateStore: StateStore): Promise<void>;

package/dist/review-completion.js

@@ -425,7 +425,7 @@ export async function runReviewCompletion(client, card, result, config, worktree
             ? getBranchWebUrl(branchName, worktreePath)
             : null;
         try {
-            await stateStore?.recordFailureSummary(card.id, {
+            await stateStore.recordFailureSummary(card.id, {
                 summary: failureSummary,
                 reason: "review",
                 recoveryBranch,

package/dist/startup-banner.js

@@ -104,7 +104,7 @@ function configRows(config, projectName, gitProvider) {
     rows.push({ label: "User", value: config.userEmail });
     const reviewEnabled = config.agent.review.enabled;
     const poolDesc = reviewEnabled
-        ? `Pool ${config.agent.poolSize} impl + 1 review`
+        ? `Pool ${config.agent.poolSize} impl + ${config.agent.review.poolSize} review`
         : `Pool ${config.agent.poolSize} impl`;
     const flowDesc = reviewEnabled
         ? `Pickup ${config.agent.pickupColumns[0]} → ${config.agent.completion.moveToColumn} → ${config.agent.review.moveToColumn}`

package/dist/types.d.ts

@@ -40,6 +40,8 @@ export interface AgentConfig {
     };
     review: {
         enabled: boolean;
+        /** Concurrent review workers. Each gets its own dev-server port slot. */
+        poolSize: number;
         pickupColumns: string[];
         moveToColumn: string;
         failColumn: string;

package/dist/types.js

@@ -1,5 +1,5 @@
 export const DEFAULT_AGENT_CONFIG = {
-    poolSize: 1,
+    poolSize: 3,
     maxTimeout: 1_800_000, // 30 minutes
     pickupColumns: ["To Do"],
     priorityLabels: { urgent: 100, critical: 90, bug: 50 },
@@ -35,6 +35,7 @@ export const DEFAULT_AGENT_CONFIG = {
     },
     review: {
         enabled: true,
+        poolSize: 2,
         pickupColumns: ["Review"],
         moveToColumn: "Done",
         failColumn: "To Do",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/agent",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Push-based agent daemon for Harmony — watches board assignments and spawns Claude CLI workers",
   "type": "module",
   "main": "dist/index.js",