@gethmy/agent 1.7.1 → 1.7.3

package/dist/queue.js

@@ -1,100 +0,0 @@
-import { log } from "./log.js";
-const TAG = "queue";
-/**
- * Priority queue for cards waiting to be worked on.
- * Sorted by: label priority boost > column position boost > enqueue time (FIFO).
- */
-export class PriorityQueue {
-    config;
-    items = [];
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * Calculate priority score for a card.
-     */
-    scoreCard(_card, column, labels) {
-        let score = 0;
-        // Label boost: highest matching label wins
-        for (const label of labels) {
-            const boost = this.config.priorityLabels[label.name.toLowerCase()] ?? 0;
-            if (boost > score)
-                score = boost;
-        }
-        // Column position boost: leftmost columns get higher priority
-        if (this.config.columnBoost) {
-            score += Math.max(0, 100 - column.position * 10);
-        }
-        return score;
-    }
-    /**
-     * Add a card to the queue. If already present, update its priority.
-     */
-    enqueue(card, column, labels, mode = "implement") {
-        const existing = this.items.findIndex((i) => i.cardId === card.id);
-        if (existing !== -1) {
-            log.debug(TAG, `Card #${card.short_id} already queued, updating priority`);
-            this.items.splice(existing, 1);
-        }
-        const priority = this.scoreCard(card, column, labels);
-        const item = {
-            cardId: card.id,
-            shortId: card.short_id,
-            title: card.title,
-            priority,
-            enqueuedAt: Date.now(),
-            mode,
-        };
-        // Insert in sorted position (highest priority first, FIFO tiebreak)
-        let insertIdx = this.items.length;
-        for (let i = 0; i < this.items.length; i++) {
-            if (priority > this.items[i].priority ||
-                (priority === this.items[i].priority &&
-                    item.enqueuedAt < this.items[i].enqueuedAt)) {
-                insertIdx = i;
-                break;
-            }
-        }
-        this.items.splice(insertIdx, 0, item);
-        log.info(TAG, `Enqueued #${card.short_id} "${card.title}" (priority=${priority}, pos=${insertIdx}, queue=${this.items.length})`);
-    }
-    /**
-     * Remove and return the highest-priority item.
-     */
-    dequeue() {
-        return this.items.shift() ?? null;
-    }
-    /**
-     * Remove a specific card from the queue.
-     */
-    remove(cardId) {
-        const idx = this.items.findIndex((i) => i.cardId === cardId);
-        if (idx === -1)
-            return null;
-        const [item] = this.items.splice(idx, 1);
-        log.info(TAG, `Removed #${item.shortId} from queue`);
-        return item;
-    }
-    /**
-     * Check if a card is in the queue.
-     */
-    has(cardId) {
-        return this.items.some((i) => i.cardId === cardId);
-    }
-    /**
-     * Get all queued card IDs.
-     */
-    cardIds() {
-        return this.items.map((i) => i.cardId);
-    }
-    get length() {
-        return this.items.length;
-    }
-    peek() {
-        return this.items[0] ?? null;
-    }
-    /** Copy of the queue in priority order (for introspection). */
-    snapshot() {
-        return this.items.slice();
-    }
-}

package/dist/reconcile.d.ts

@@ -1,35 +0,0 @@
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { Pool } from "./pool.js";
-import type { StateStore } from "./state-store.js";
-import { type AgentConfig } from "./types.js";
-/**
- * Reconciliation heartbeat: polls the board every `intervalMs` to catch
- * missed realtime events and sync state.
- */
-export declare class Reconciler {
-    private client;
-    private pool;
-    private projectId;
-    private agentUserId;
-    private pickupColumns;
-    private reviewColumns;
-    private approvedLabel;
-    private intervalMs;
-    private stateStore?;
-    private agentConfig?;
-    private timer;
-    private lastTickAt;
-    get lastTick(): number | null;
-    get isRunning(): boolean;
-    constructor(client: HarmonyApiClient, pool: Pool, projectId: string, agentUserId: string, pickupColumns: string[], reviewColumns: string[], approvedLabel: string, intervalMs?: number, stateStore?: StateStore | undefined, agentConfig?: AgentConfig | undefined);
-    start(): void;
-    stop(): void;
-    /**
-     * Walk the state store for runs marked active whose owning daemon is
-     * dead OR whose heartbeat is stale. Each such run gets the same
-     * recovery treatment as startup orphans: session ended, card returned
-     * to pickup column with agent-recovered label, worktree cleaned up.
-     */
-    private recoverStaleRuns;
-    private tick;
-}

package/dist/reconcile.js

@@ -1,174 +0,0 @@
-import { buildLabelMap, hasLabel, resolveCardLabels } from "./board-helpers.js";
-import { log } from "./log.js";
-import { isProcessAlive, recoverRun } from "./recovery.js";
-import { extractBranchFromDescription } from "./review-worktree.js";
-import { NEED_REVIEW_LABEL } from "./types.js";
-const TAG = "reconcile";
-/**
- * Reconciliation heartbeat: polls the board every `intervalMs` to catch
- * missed realtime events and sync state.
- */
-export class Reconciler {
-    client;
-    pool;
-    projectId;
-    agentUserId;
-    pickupColumns;
-    reviewColumns;
-    approvedLabel;
-    intervalMs;
-    stateStore;
-    agentConfig;
-    timer = null;
-    lastTickAt = null;
-    get lastTick() {
-        return this.lastTickAt;
-    }
-    get isRunning() {
-        return this.timer !== null;
-    }
-    constructor(client, pool, projectId, agentUserId, pickupColumns, reviewColumns, approvedLabel, intervalMs = 60_000, stateStore, agentConfig) {
-        this.client = client;
-        this.pool = pool;
-        this.projectId = projectId;
-        this.agentUserId = agentUserId;
-        this.pickupColumns = pickupColumns;
-        this.reviewColumns = reviewColumns;
-        this.approvedLabel = approvedLabel;
-        this.intervalMs = intervalMs;
-        this.stateStore = stateStore;
-        this.agentConfig = agentConfig;
-    }
-    start() {
-        // Run immediately, then on interval
-        this.tick();
-        this.timer = setInterval(() => this.tick(), this.intervalMs);
-    }
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-        log.info(TAG, "Heartbeat stopped");
-    }
-    /**
-     * Walk the state store for runs marked active whose owning daemon is
-     * dead OR whose heartbeat is stale. Each such run gets the same
-     * recovery treatment as startup orphans: session ended, card returned
-     * to pickup column with agent-recovered label, worktree cleaned up.
-     */
-    async recoverStaleRuns() {
-        if (!this.stateStore || !this.agentConfig)
-            return;
-        const now = Date.now();
-        const stale = this.agentConfig.timing.staleHeartbeatMs;
-        const active = this.stateStore.getActiveRuns();
-        const pool = this.pool;
-        for (const run of active) {
-            const foreignDaemon = run.daemonPid !== process.pid;
-            const daemonDead = foreignDaemon && !isProcessAlive(run.daemonPid, process.pid);
-            const heartbeatStale = now - run.lastHeartbeatAt > stale;
-            const ourZombie = !foreignDaemon && !pool.isCardActive(run.cardId);
-            if (!daemonDead && !(heartbeatStale && ourZombie))
-                continue;
-            const reason = daemonDead
-                ? `foreign daemon ${run.daemonPid} is dead`
-                : `our worker lost card ${run.cardId} with ${Math.round((now - run.lastHeartbeatAt) / 1000)}s stale heartbeat`;
-            log.warn(TAG, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
-            await recoverRun(run, this.stateStore, this.client, this.agentConfig, {
-                runId: run.runId,
-                cardId: run.cardId,
-                cardShortId: run.cardShortId,
-                pipeline: run.pipeline,
-                actions: [],
-                errors: [],
-            });
-        }
-    }
-    async tick() {
-        this.lastTickAt = Date.now();
-        try {
-            const board = await this.client.getBoard(this.projectId);
-            const cards = (board.cards ?? []);
-            const columns = (board.columns ?? []);
-            // Build label lookup (id → Label) to resolve card.labelIds
-            const labelMap = buildLabelMap((board.labels ?? []));
-            // Build a lookup of columns by ID
-            const columnMap = new Map();
-            for (const col of columns) {
-                columnMap.set(col.id, col);
-            }
-            // Build column ID sets for both modes
-            const pickupColumnIds = new Set(columns
-                .filter((c) => this.pickupColumns.some((name) => name.toLowerCase() === c.name.toLowerCase()))
-                .map((c) => c.id));
-            const reviewColumnIds = new Set(columns
-                .filter((c) => this.reviewColumns.some((name) => name.toLowerCase() === c.name.toLowerCase()))
-                .map((c) => c.id));
-            // Find cards assigned to our agent in either pickup or review columns
-            const assignedCards = cards.filter((c) => c.assignee_id === this.agentUserId &&
-                !c.archived_at &&
-                (pickupColumnIds.has(c.column_id) ||
-                    reviewColumnIds.has(c.column_id)));
-            const knownCardIds = this.pool.knownCardIds();
-            // All cards still assigned to the agent (any column) — used to detect
-            // genuine unassigns without false-positiving on cards the worker moved
-            // to "In Progress" or other non-pickup columns.
-            const allAgentCardIds = new Set(cards
-                .filter((c) => c.assignee_id === this.agentUserId && !c.archived_at)
-                .map((c) => c.id));
-            // Cards assigned but NOT in queue/active → enqueue (missed event)
-            for (const card of assignedCards) {
-                if (!knownCardIds.has(card.id)) {
-                    const column = columnMap.get(card.column_id);
-                    if (!column)
-                        continue;
-                    const cardLabels = resolveCardLabels(card, labelMap);
-                    const subtasks = card.subtasks ?? [];
-                    // Determine mode based on which column set the card is in
-                    const mode = reviewColumnIds.has(card.column_id)
-                        ? "review"
-                        : "implement";
-                    // Skip already-approved cards in review mode
-                    if (mode === "review" &&
-                        this.approvedLabel &&
-                        hasLabel(cardLabels, this.approvedLabel)) {
-                        log.debug(TAG, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
-                        continue;
-                    }
-                    // Skip cards with "Need Review" label (awaiting human review)
-                    if (mode === "review" && hasLabel(cardLabels, NEED_REVIEW_LABEL)) {
-                        log.debug(TAG, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
-                        continue;
-                    }
-                    // Skip review for cards without a branch reference — not qualified for auto-review
-                    if (mode === "review" &&
-                        !extractBranchFromDescription(card.description)) {
-                        log.debug(TAG, `Skipping #${card.short_id} — no branch reference (not qualified for auto-review)`);
-                        continue;
-                    }
-                    log.info(TAG, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
-                    await this.pool.enqueue(card, column, cardLabels, subtasks, mode);
-                }
-            }
-            // Detect zombie runs: state-store says active, but either:
-            //  (a) another daemon's PID is dead, or
-            //  (b) our daemon holds the run but no worker is on the card, or
-            //  (c) heartbeat is older than staleHeartbeatMs.
-            if (this.stateStore && this.agentConfig) {
-                await this.recoverStaleRuns();
-            }
-            // Cards in queue/active but no longer assigned to agent → cancel/remove
-            for (const knownId of knownCardIds) {
-                if (!allAgentCardIds.has(knownId)) {
-                    log.info(TAG, `Missed unassign: ${knownId} — removing`);
-                    await this.pool.removeCard(knownId);
-                }
-            }
-            log.debug(TAG, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
-        }
-        catch (err) {
-            log.error(TAG, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-}

package/dist/recovery.d.ts

@@ -1,30 +0,0 @@
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { RunRecord, StateStore } from "./state-store.js";
-import type { AgentConfig } from "./types.js";
-export interface RecoveryOutcome {
-    runId: string;
-    cardId: string;
-    cardShortId: number;
-    pipeline: "implement" | "review";
-    actions: string[];
-    errors: string[];
-}
-/**
- * Check if a process is still alive. A crashed daemon's PID is unlikely
- * to be reused within a reboot window; if it is, we still treat it as
- * orphaned because our current process is the new daemon.
- */
-export declare function isProcessAlive(pid: number, currentPid: number): boolean;
-/**
- * Reconcile orphaned runs from a previous daemon life.
- *
- * For each active run in the state store:
- *  - If the daemon PID is alive (should not happen for a fresh process),
- *    skip it — it's another instance.
- *  - Otherwise: end the Harmony session, return the card to its pickup
- *    column with the `agent-recovered` label, and cleanup the worktree.
- *
- * This runs once at daemon startup, before the pool accepts work.
- */
-export declare function recoverOrphans(store: StateStore, client: HarmonyApiClient, config: AgentConfig): Promise<RecoveryOutcome[]>;
-export declare function recoverRun(run: RunRecord, store: StateStore, client: HarmonyApiClient, config: AgentConfig, outcome: RecoveryOutcome): Promise<void>;

package/dist/recovery.js

@@ -1,141 +0,0 @@
-import { addLabelByName, moveCardToColumn } from "./board-helpers.js";
-import { log } from "./log.js";
-import { cleanupWorktree } from "./worktree.js";
-const TAG = "recovery";
-const RECOVERED_LABEL = "agent-recovered";
-const RECOVERED_LABEL_COLOR = "#f59e0b";
-/**
- * Check if a process is still alive. A crashed daemon's PID is unlikely
- * to be reused within a reboot window; if it is, we still treat it as
- * orphaned because our current process is the new daemon.
- */
-export function isProcessAlive(pid, currentPid) {
-    if (pid === currentPid)
-        return true;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function fetchCardSafely(client, cardId) {
-    try {
-        const { card } = (await client.getCard(cardId));
-        return card;
-    }
-    catch (err) {
-        log.warn(TAG, `cannot fetch card ${cardId}: ${err instanceof Error ? err.message : err}`);
-        return null;
-    }
-}
-/**
- * Reconcile orphaned runs from a previous daemon life.
- *
- * For each active run in the state store:
- *  - If the daemon PID is alive (should not happen for a fresh process),
- *    skip it — it's another instance.
- *  - Otherwise: end the Harmony session, return the card to its pickup
- *    column with the `agent-recovered` label, and cleanup the worktree.
- *
- * This runs once at daemon startup, before the pool accepts work.
- */
-export async function recoverOrphans(store, client, config) {
-    const active = store.getActiveRuns();
-    if (active.length === 0) {
-        return [];
-    }
-    const outcomes = [];
-    log.info(TAG, `recovering ${active.length} orphan run(s) from prior daemon`);
-    for (const run of active) {
-        const outcome = {
-            runId: run.runId,
-            cardId: run.cardId,
-            cardShortId: run.cardShortId,
-            pipeline: run.pipeline,
-            actions: [],
-            errors: [],
-        };
-        outcomes.push(outcome);
-        if (isProcessAlive(run.daemonPid, process.pid)) {
-            log.warn(TAG, `run ${run.runId} claims live daemon pid ${run.daemonPid} — skipping`);
-            outcome.actions.push("skipped: daemon pid still alive");
-            continue;
-        }
-        log.info(TAG, `recovering ${run.pipeline} run ${run.runId} for card #${run.cardShortId}`);
-        await recoverRun(run, store, client, config, outcome);
-    }
-    return outcomes;
-}
-export async function recoverRun(run, store, client, config, outcome) {
-    // 1. End the agent session so the card stops showing the progress ring.
-    // Mark as failed (not paused) — daemon crash is an outcome, not a
-    // user-initiated pause. UI renders the destructive tint + recovery branch
-    // button if the run had pushed any commits.
-    try {
-        await client.endAgentSession(run.cardId, {
-            status: "failed",
-            failureReason: "daemon_restart",
-            failureSummary: `Daemon restarted mid-${run.pipeline} (phase: ${run.phase})`,
-            recoveryBranch: run.branchName ?? undefined,
-            progressPercent: run.phase === "completing" ? 95 : undefined,
-        });
-        outcome.actions.push("ended agent session (failed: daemon_restart)");
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        outcome.errors.push(`endAgentSession: ${msg}`);
-        log.warn(TAG, `endAgentSession failed for ${run.cardId}: ${msg}`);
-    }
-    // 2. Move card back to a safe column and add the recovered label.
-    //    - implement pipeline → pickup column (usually "To Do")
-    //    - review pipeline → leave in place (reviewer will re-pick)
-    const card = await fetchCardSafely(client, run.cardId);
-    if (card) {
-        if (run.pipeline === "implement") {
-            const target = config.pickupColumns[0];
-            if (target) {
-                try {
-                    await moveCardToColumn(client, card, target);
-                    outcome.actions.push(`moved to "${target}"`);
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    outcome.errors.push(`moveCardToColumn: ${msg}`);
-                }
-            }
-        }
-        try {
-            await addLabelByName(client, card, RECOVERED_LABEL, RECOVERED_LABEL_COLOR);
-            outcome.actions.push(`labeled "${RECOVERED_LABEL}"`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            outcome.errors.push(`addLabel: ${msg}`);
-        }
-    }
-    else {
-        outcome.actions.push("card not reachable — local cleanup only");
-    }
-    // 3. Cleanup local worktree so it doesn't collide with future runs.
-    if (run.worktreePath) {
-        try {
-            cleanupWorktree(run.worktreePath, run.branchName ?? undefined);
-            outcome.actions.push("cleaned up worktree");
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            outcome.errors.push(`cleanupWorktree: ${msg}`);
-        }
-    }
-    // 4. Mark the run as orphaned in the store.
-    try {
-        await store.endRun(run.runId, "orphaned", "recovered after daemon restart");
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        outcome.errors.push(`endRun: ${msg}`);
-    }
-    log.info(TAG, `recovered run ${run.runId} (card #${run.cardShortId}): ${outcome.actions.join(", ")}${outcome.errors.length ? ` | errors: ${outcome.errors.join("; ")}` : ""}`);
-}

package/dist/review-completion.d.ts

@@ -1,35 +0,0 @@
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { Card } from "@harmony/shared";
-import { type SessionStats } from "./completion.js";
-import type { StateStore } from "./state-store.js";
-import { type AgentConfig } from "./types.js";
-export interface ReviewFinding {
-    severity: "critical" | "major" | "minor";
-    title: string;
-    description: string;
-    category?: string;
-    location?: string;
-}
-export interface ScopeCheck {
-    status: "clean" | "drift" | "missing";
-    notes?: string;
-}
-export interface ReviewResult {
-    verdict: "approved" | "rejected" | "error";
-    summary: string;
-    scopeCheck?: ScopeCheck;
-    findings: ReviewFinding[];
-}
-/**
- * Parse Claude's review output into a structured ReviewResult.
- *
- * 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 declare function parseReviewOutput(stdout: string): ReviewResult;
-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>;