@gethmy/agent 1.3.0 → 1.4.2

package/dist/review-worker.js

@@ -1,4 +1,5 @@
 import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { addLabelByName, moveCardToColumn } from "./board-helpers.js";
 import { buildTokenPayload } from "./completion.js";
 import { log } from "./log.js";
@@ -214,6 +215,30 @@ export class ReviewWorker {
             };
             const systemPrompt = buildReviewSystemPrompt();
             const userPrompt = buildReviewUserPrompt(enriched, this.branchName, cwd, previewUrl, diff, this.config.worktree.baseBranch);
+            // AGP P2: persist a session-linked snapshot of the review system
+            // prompt so outcome feedback can credit / penalise the framing.
+            // Best-effort — never block review on logging.
+            try {
+                const sessionResp = await this.client.getAgentSession(card.id);
+                const reviewSession = sessionResp.session;
+                const reviewSessionId = reviewSession?.id ?? null;
+                const contentHash = createHash("sha256")
+                    .update(systemPrompt)
+                    .digest("hex");
+                await this.client.recordPromptHistory({
+                    cardId: card.id,
+                    generatedPrompt: systemPrompt,
+                    variant: "execute",
+                    contextIncluded: { source: "review-knowledge", mode: "review" },
+                    sessionId: reviewSessionId,
+                    contentHash,
+                    templateVersion: 1,
+                    confidence: 0.5,
+                });
+            }
+            catch (err) {
+                log.warn(this.tag, `prompt_history persistence skipped: ${err instanceof Error ? err.message : String(err)}`);
+            }
             await this.client.updateAgentProgress(card.id, {
                 agentIdentifier: agentIdentifier(this.id),
                 agentName: `${AGENT_NAME} (Review)`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/agent",
-  "version": "1.3.0",
+  "version": "1.4.2",
   "description": "Push-based agent daemon for Harmony — watches board assignments and spawns Claude CLI workers",
   "type": "module",
   "main": "dist/index.js",
@@ -38,7 +38,7 @@
   "scripts": {
     "start": "node dist/index.js",
     "prebuild": "cd ../harmony-shared && bun run build && cd ../memory && bun run build",
-    "build": "tsc",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",
     "test": "vitest run"

package/dist/__tests__/budget.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/budget.test.js

@@ -1,94 +0,0 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { BudgetGuard } from "../budget.js";
-import { StateStore } from "../state-store.js";
-import { DEFAULT_AGENT_CONFIG } from "../types.js";
-describe("BudgetGuard", () => {
-    let dir;
-    let store;
-    beforeEach(() => {
-        dir = mkdtempSync(join(tmpdir(), "budget-"));
-        store = new StateStore(join(dir, "state.json"));
-    });
-    afterEach(() => {
-        rmSync(dir, { recursive: true, force: true });
-    });
-    function makeGuard(overrides = {}) {
-        return new BudgetGuard({ ...DEFAULT_AGENT_CONFIG.budget, ...overrides }, store);
-    }
-    it("allows a fresh card with no history", () => {
-        const guard = makeGuard();
-        expect(guard.check("c1")).toEqual({ allow: true });
-    });
-    it("blocks a card already marked DLQ", async () => {
-        await store.markDlq("c1", "upstream test");
-        const guard = makeGuard();
-        const decision = guard.check("c1");
-        expect(decision).toMatchObject({ allow: false, reason: "dlq" });
-    });
-    it("blocks after attempts >= max", async () => {
-        await store.incrementAttempt("c1");
-        await store.incrementAttempt("c1");
-        await store.incrementAttempt("c1");
-        const guard = makeGuard({ maxAttemptsPerCard: 3 });
-        const decision = guard.check("c1");
-        expect(decision).toMatchObject({
-            allow: false,
-            reason: "max_attempts",
-        });
-    });
-    it("allows again after recordOutcome('success') resets attempts", async () => {
-        await store.incrementAttempt("c1");
-        await store.incrementAttempt("c1");
-        await store.recordOutcome("c1", "success");
-        const guard = makeGuard({ maxAttemptsPerCard: 2 });
-        expect(guard.check("c1")).toEqual({ allow: true });
-    });
-    it("blocks on per-card cost cap", async () => {
-        await store.addCost("c1", 600);
-        const guard = makeGuard({ maxCentsPerCard: 500 });
-        expect(guard.check("c1")).toMatchObject({
-            allow: false,
-            reason: "card_cost_cap",
-        });
-    });
-    it("blocks on daily budget exhaustion", async () => {
-        await store.addCost("c1", 5000);
-        const guard = makeGuard({ dailyBudgetCents: 5000 });
-        // Different card, but daily aggregate already at cap.
-        expect(guard.check("c2")).toMatchObject({
-            allow: false,
-            reason: "daily_budget",
-        });
-    });
-    it("treats DLQ, max_attempts, card_cost_cap as terminal (daily_budget is not)", () => {
-        const guard = makeGuard();
-        expect(guard.isTerminal("dlq")).toBe(true);
-        expect(guard.isTerminal("max_attempts")).toBe(true);
-        expect(guard.isTerminal("card_cost_cap")).toBe(true);
-        expect(guard.isTerminal("daily_budget")).toBe(false);
-    });
-    it("markDlq persists state + applies label via runTransition", async () => {
-        const guard = makeGuard();
-        const client = {
-            getBoard: vi.fn().mockResolvedValue({
-                columns: [{ id: "col-1", name: "To Do" }],
-                labels: [],
-            }),
-            createLabel: vi.fn().mockResolvedValue({ label: { id: "lbl-dlq" } }),
-            addLabelToCard: vi.fn().mockResolvedValue({}),
-        };
-        const card = {
-            id: "c1",
-            short_id: 99,
-            project_id: "p",
-            column_id: "col-1",
-            labelIds: [],
-        };
-        await guard.markDlq(client, card, "max_attempts", "3 attempts");
-        expect(store.isDlq("c1")).toBe(true);
-        expect(client.addLabelToCard).toHaveBeenCalledWith("c1", "lbl-dlq");
-    });
-});

package/dist/__tests__/config-validation.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/config-validation.test.js

@@ -1,65 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { ConfigValidationError, validateColumnReferences, } from "../config-validation.js";
-import { DEFAULT_AGENT_CONFIG } from "../types.js";
-function makeClient(columns) {
-    return {
-        getBoard: vi.fn().mockResolvedValue({
-            columns: columns.map((name, i) => ({ id: `col-${i}`, name })),
-            labels: [],
-        }),
-    };
-}
-describe("validateColumnReferences", () => {
-    it("passes when all configured columns exist (case-insensitive)", async () => {
-        const client = makeClient([
-            "to do",
-            "In Progress",
-            "REVIEW",
-            "Done",
-            "Needs Fix",
-        ]);
-        await expect(validateColumnReferences(client, "proj", DEFAULT_AGENT_CONFIG)).resolves.toBeUndefined();
-    });
-    it("throws a typed error listing every missing column", async () => {
-        const client = makeClient(["To Do", "Review", "Done"]);
-        const config = {
-            ...DEFAULT_AGENT_CONFIG,
-            verification: {
-                ...DEFAULT_AGENT_CONFIG.verification,
-                failColumn: "Needs Fix",
-            },
-        };
-        try {
-            await validateColumnReferences(client, "proj", config);
-            throw new Error("expected rejection");
-        }
-        catch (err) {
-            expect(err).toBeInstanceOf(ConfigValidationError);
-            const issues = err.issues;
-            expect(issues.some((i) => i.includes("Needs Fix"))).toBe(true);
-        }
-    });
-    it("skips review column checks when review is disabled", async () => {
-        const client = makeClient(["To Do", "Review", "Needs Fix"]);
-        const config = {
-            ...DEFAULT_AGENT_CONFIG,
-            completion: {
-                ...DEFAULT_AGENT_CONFIG.completion,
-                moveToColumn: "Review",
-            },
-            review: { ...DEFAULT_AGENT_CONFIG.review, enabled: false },
-        };
-        await expect(validateColumnReferences(client, "proj", config)).resolves.toBeUndefined();
-    });
-    it("reports the missing column along with the config path", async () => {
-        const client = makeClient(["To Do", "In Progress", "Review", "Done"]);
-        const config = {
-            ...DEFAULT_AGENT_CONFIG,
-            verification: {
-                ...DEFAULT_AGENT_CONFIG.verification,
-                failColumn: "DOES NOT EXIST",
-            },
-        };
-        await expect(validateColumnReferences(client, "proj", config)).rejects.toThrow(/verification\.failColumn: column "DOES NOT EXIST"/);
-    });
-});

package/dist/__tests__/dev-server-readiness.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/dev-server-readiness.test.js

@@ -1,26 +0,0 @@
-import { spawn } from "node:child_process";
-import { describe, expect, it } from "vitest";
-import { DevServerReadinessError, waitForDevServer } from "../verification.js";
-describe("waitForDevServer", () => {
-    it("resolves when readiness signal appears on stdout", async () => {
-        // node -e "console.log('server ready on localhost:4200'); setTimeout(()=>{}, 1000)"
-        const proc = spawn(process.execPath, [
-            "-e",
-            "console.log('server ready on localhost:4200'); setTimeout(() => {}, 1000);",
-        ], { stdio: ["ignore", "pipe", "pipe"] });
-        await expect(waitForDevServer(proc, 2000)).resolves.toBeUndefined();
-        proc.kill("SIGKILL");
-    });
-    it("rejects (does NOT resolve) on timeout", async () => {
-        // Silent child; no readiness signal.
-        const proc = spawn(process.execPath, ["-e", "setTimeout(() => {}, 5000);"], { stdio: ["ignore", "pipe", "pipe"] });
-        await expect(waitForDevServer(proc, 100)).rejects.toBeInstanceOf(DevServerReadinessError);
-        proc.kill("SIGKILL");
-    });
-    it("rejects if the process exits before becoming ready", async () => {
-        const proc = spawn(process.execPath, ["-e", "process.exit(7);"], {
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        await expect(waitForDevServer(proc, 5000)).rejects.toBeInstanceOf(DevServerReadinessError);
-    });
-});

package/dist/__tests__/http-server.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/http-server.test.js

@@ -1,115 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { HttpServer, } from "../http-server.js";
-function baseStatus() {
-    return {
-        daemonId: "d-1",
-        daemonPid: 1234,
-        startedAt: Date.now(),
-        uptimeMs: 0,
-        workers: [],
-        implQueue: [],
-        reviewQueue: [],
-        dlq: [],
-        budget: { todayCents: 0, dailyCapCents: 5000 },
-    };
-}
-describe("HttpServer", () => {
-    let server;
-    let port;
-    let getHealth;
-    let handleCommand;
-    let clearDlq;
-    beforeEach(async () => {
-        // Ephemeral port via 0 doesn't round-trip through the options — use
-        // a random high port and retry on collision (rare in CI).
-        port = 40000 + Math.floor(Math.random() * 10000);
-        getHealth = () => ({ healthy: true, checks: { watcher: true } });
-        handleCommand = vi.fn().mockResolvedValue(undefined);
-        clearDlq = vi.fn().mockResolvedValue(undefined);
-        server = new HttpServer({
-            port,
-            bindAddr: "127.0.0.1",
-            getHealth: () => getHealth(),
-            getStatus: () => baseStatus(),
-            handleCommand: (c, id) => handleCommand(c, id),
-            clearDlq: (id) => clearDlq(id),
-        });
-        await server.start();
-    });
-    afterEach(async () => {
-        await server.stop();
-    });
-    async function get(path) {
-        return fetch(`http://127.0.0.1:${port}${path}`);
-    }
-    async function post(path) {
-        return fetch(`http://127.0.0.1:${port}${path}`, { method: "POST" });
-    }
-    it("GET /health returns 200 when healthy", async () => {
-        const res = await get("/health");
-        expect(res.status).toBe(200);
-        const body = await res.json();
-        expect(body.healthy).toBe(true);
-    });
-    it("GET /health returns 503 when unhealthy", async () => {
-        getHealth = () => ({
-            healthy: false,
-            checks: { watcher: false, reconciler: true },
-        });
-        const res = await get("/health");
-        expect(res.status).toBe(503);
-        const body = await res.json();
-        expect(body.checks.watcher).toBe(false);
-    });
-    it("GET /status returns the snapshot shape", async () => {
-        const res = await get("/status");
-        expect(res.status).toBe(200);
-        const body = await res.json();
-        expect(body).toHaveProperty("daemonId", "d-1");
-        expect(body).toHaveProperty("workers");
-        expect(body).toHaveProperty("implQueue");
-        expect(body).toHaveProperty("dlq");
-        expect(body).toHaveProperty("budget");
-    });
-    it("POST /pause/:cardId dispatches to handleCommand", async () => {
-        const res = await post("/pause/abc-123");
-        expect(res.status).toBe(200);
-        expect(handleCommand).toHaveBeenCalledWith("pause", "abc-123");
-    });
-    it("POST /resume/:cardId dispatches correctly", async () => {
-        const res = await post("/resume/xyz");
-        expect(res.status).toBe(200);
-        expect(handleCommand).toHaveBeenCalledWith("resume", "xyz");
-    });
-    it("POST /stop/:cardId dispatches correctly", async () => {
-        const res = await post("/stop/c1");
-        expect(res.status).toBe(200);
-        expect(handleCommand).toHaveBeenCalledWith("stop", "c1");
-    });
-    it("returns 404 for unknown paths", async () => {
-        const res = await get("/does-not-exist");
-        expect(res.status).toBe(404);
-    });
-    it("POST /dlq/clear/:cardId routes through the daemon", async () => {
-        const res = await post("/dlq/clear/card-42");
-        expect(res.status).toBe(200);
-        expect(clearDlq).toHaveBeenCalledWith("card-42");
-        const body = await res.json();
-        expect(body.ok).toBe(true);
-        expect(body.cardId).toBe("card-42");
-    });
-    it("POST /dlq/clear returns 500 with detail on failure", async () => {
-        clearDlq = vi.fn().mockRejectedValue(new Error("state store locked"));
-        const res = await post("/dlq/clear/card-99");
-        expect(res.status).toBe(500);
-        const body = await res.json();
-        expect(body.detail).toContain("state store locked");
-    });
-    it("returns 500 with detail when handleCommand throws", async () => {
-        handleCommand = vi.fn().mockRejectedValue(new Error("worker gone"));
-        const res = await post("/stop/c1");
-        expect(res.status).toBe(500);
-        const body = await res.json();
-        expect(body.detail).toContain("worker gone");
-    });
-});

package/dist/__tests__/log.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/log.test.js

@@ -1,115 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-describe("log", () => {
-    let writes;
-    let origWrite;
-    let origArgv;
-    beforeEach(() => {
-        writes = [];
-        origWrite = process.stderr.write;
-        origArgv = process.argv;
-        process.stderr.write = ((chunk) => {
-            writes.push(chunk);
-            return true;
-        });
-        delete process.env.HARMONY_AGENT_PRETTY;
-        delete process.env.HARMONY_AGENT_JSON;
-        delete process.env.DEBUG;
-        vi.resetModules();
-    });
-    afterEach(() => {
-        process.stderr.write = origWrite;
-        process.argv = origArgv;
-    });
-    it("emits JSON lines when stderr is not a TTY", async () => {
-        // Vitest stderr is not a TTY by default; no need to force.
-        const { log } = await import("../log.js");
-        log.info("worker", "hello", { cardId: "c1", runId: "r1" });
-        const parsed = JSON.parse(writes[0]);
-        expect(parsed).toMatchObject({
-            level: "info",
-            tag: "worker",
-            msg: "hello",
-            cardId: "c1",
-            runId: "r1",
-        });
-        expect(parsed.ts).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-    });
-    it("emits pretty output when stderr is a TTY", async () => {
-        const originalIsTTY = process.stderr.isTTY;
-        Object.defineProperty(process.stderr, "isTTY", {
-            value: true,
-            configurable: true,
-        });
-        try {
-            const { log } = await import("../log.js");
-            log.info("daemon", "up");
-            expect(() => JSON.parse(writes[0])).toThrow();
-            expect(writes[0]).toContain("INFO");
-            expect(writes[0]).toContain("[daemon]");
-        }
-        finally {
-            Object.defineProperty(process.stderr, "isTTY", {
-                value: originalIsTTY,
-                configurable: true,
-            });
-        }
-    });
-    it("--json forces JSON even on a TTY", async () => {
-        const originalIsTTY = process.stderr.isTTY;
-        Object.defineProperty(process.stderr, "isTTY", {
-            value: true,
-            configurable: true,
-        });
-        process.argv = [...process.argv, "--json"];
-        try {
-            const { log } = await import("../log.js");
-            log.info("daemon", "up");
-            const parsed = JSON.parse(writes[0]);
-            expect(parsed.msg).toBe("up");
-        }
-        finally {
-            Object.defineProperty(process.stderr, "isTTY", {
-                value: originalIsTTY,
-                configurable: true,
-            });
-        }
-    });
-    it("HARMONY_AGENT_JSON=1 beats HARMONY_AGENT_PRETTY=1", async () => {
-        process.env.HARMONY_AGENT_PRETTY = "1";
-        process.env.HARMONY_AGENT_JSON = "1";
-        const { log } = await import("../log.js");
-        log.info("daemon", "hi");
-        const parsed = JSON.parse(writes[0]);
-        expect(parsed.msg).toBe("hi");
-    });
-    it("suppresses debug when DEBUG is unset", async () => {
-        const { log } = await import("../log.js");
-        log.debug("x", "quiet");
-        expect(writes).toEqual([]);
-    });
-    it("emits debug when DEBUG is set", async () => {
-        process.env.DEBUG = "1";
-        const { log } = await import("../log.js");
-        log.debug("x", "loud");
-        expect(writes).toHaveLength(1);
-        const parsed = JSON.parse(writes[0]);
-        expect(parsed.level).toBe("debug");
-    });
-    it("log.event attaches the event field", async () => {
-        const { log } = await import("../log.js");
-        log.event("pool", "card_enqueued", { cardId: "c2" });
-        const parsed = JSON.parse(writes[0]);
-        expect(parsed.event).toBe("card_enqueued");
-        expect(parsed.msg).toBe("card_enqueued");
-        expect(parsed.cardId).toBe("c2");
-    });
-    it("switches to ANSI pretty output under HARMONY_AGENT_PRETTY=1", async () => {
-        process.env.HARMONY_AGENT_PRETTY = "1";
-        const { log } = await import("../log.js");
-        log.warn("daemon", "heads up");
-        // Pretty output is not JSON — should fail parse and contain WARN label
-        expect(() => JSON.parse(writes[0])).toThrow();
-        expect(writes[0]).toContain("WARN");
-        expect(writes[0]).toContain("[daemon]");
-    });
-});

package/dist/__tests__/merge-monitor.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/merge-monitor.test.js

@@ -1,107 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { MergeMonitor } from "../merge-monitor.js";
-vi.mock("../git-pr.js", () => ({
-    detectGitProvider: () => "github",
-    extractPrUrl: () => "https://example/pr/1",
-    checkPrMergeStatus: vi.fn().mockResolvedValue("merged"),
-}));
-vi.mock("node:child_process", () => ({
-    execFile: (_a, _b, _c, cb) => cb(null),
-}));
-function makeCard(overrides = {}) {
-    return {
-        id: "card-1",
-        short_id: 42,
-        project_id: "proj",
-        title: "Card",
-        description: "branch: agent/foo\n\nhttps://example/pr/1",
-        column_id: "col-review",
-        labelIds: ["lbl-approved"],
-        done: false,
-        archived_at: null,
-        ...overrides,
-    };
-}
-function makeConfig() {
-    return {
-        review: {
-            enabled: true,
-            pickupColumns: ["Review"],
-            moveToColumn: "Done",
-            failColumn: "To Do",
-            devServerPort: 4300,
-            maxTimeout: 600_000,
-            postFindings: true,
-            maxReviewCycles: 3,
-            createPR: true,
-            approvedLabel: "Ready to Merge",
-            approvedLabelColor: "#22c55e",
-            mergeMonitor: true,
-            mergedLabel: "Merged",
-            mergedLabelColor: "#6366f1",
-        },
-    };
-}
-function makeBoard(markCardsDone) {
-    return {
-        columns: [
-            { id: "col-review", name: "Review", mark_cards_done: false },
-            { id: "col-done", name: "Done", mark_cards_done: markCardsDone },
-        ],
-        labels: [
-            { id: "lbl-approved", name: "Ready to Merge" },
-            { id: "lbl-merged", name: "Merged" },
-        ],
-        cards: [makeCard()],
-    };
-}
-function makeClient(markCardsDone) {
-    return {
-        getBoard: vi.fn().mockResolvedValue(makeBoard(markCardsDone)),
-        moveCard: vi.fn().mockResolvedValue({}),
-        addLabelToCard: vi.fn().mockResolvedValue({}),
-        removeLabelFromCard: vi.fn().mockResolvedValue({}),
-        createLabel: vi.fn().mockResolvedValue({ label: { id: "lbl-new" } }),
-        updateCard: vi.fn().mockResolvedValue({}),
-    };
-}
-function approvedLabel() {
-    return { id: "lbl-approved", name: "Ready to Merge" };
-}
-function asPrivate(monitor) {
-    return monitor;
-}
-describe("MergeMonitor.completeMergedCard", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("does NOT force done:true when Done column has mark_cards_done=false", async () => {
-        const client = makeClient(false);
-        const monitor = asPrivate(new MergeMonitor(client, "proj", makeConfig()));
-        await monitor.completeMergedCard(makeCard(), [approvedLabel()]);
-        const updateCalls = client.updateCard.mock.calls;
-        for (const [, payload] of updateCalls) {
-            expect(payload).not.toHaveProperty("done");
-        }
-    });
-    it("moves to the configured Done column and updates description with merge timestamp", async () => {
-        const client = makeClient(true);
-        const monitor = asPrivate(new MergeMonitor(client, "proj", makeConfig()));
-        await monitor.completeMergedCard(makeCard(), [approvedLabel()]);
-        expect(client.moveCard).toHaveBeenCalledWith("card-1", "col-done");
-        const descUpdate = client.updateCard.mock.calls.find(([, p]) => typeof p.description === "string" &&
-            p.description.includes("Merged at"));
-        expect(descUpdate).toBeDefined();
-    });
-    it("does not re-append merge timestamp when description already has one", async () => {
-        const client = makeClient(true);
-        const monitor = asPrivate(new MergeMonitor(client, "proj", makeConfig()));
-        const card = makeCard({
-            description: "branch: agent/foo\n\nMerged at 2026-01-01T00:00:00Z",
-        });
-        await monitor.completeMergedCard(card, [approvedLabel()]);
-        for (const [, payload] of client.updateCard.mock.calls) {
-            expect(payload).not.toHaveProperty("description");
-        }
-    });
-});

package/dist/__tests__/process-group.test.d.ts

@@ -1 +0,0 @@
-export {};