@gethmy/agent 1.1.1 → 1.2.0

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

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

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

@@ -0,0 +1,107 @@
+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.js

@@ -1,5 +1,27 @@
 import { describe, expect, it } from "vitest";
 import { signalGroup, spawnInGroup, terminateGroup } from "../process-group.js";
+/**
+ * Wait until the child writes a "ready" line to stdout. This is the only
+ * reliable way to know a Node child has actually installed its signal
+ * handlers — time-based waits flake under CI/test-suite load because the
+ * handler may not be registered before the test sends SIGTERM, in which case
+ * Node's default handler terminates the process and the escalation test
+ * can't observe SIGKILL. Child scripts in this file print "ready\n" after
+ * calling process.on(...).
+ */
+function waitForReady(proc, timeoutMs = 3000) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("child never reported ready")), timeoutMs);
+        let buf = "";
+        proc.stdout?.on("data", (d) => {
+            buf += d.toString();
+            if (buf.includes("ready")) {
+                clearTimeout(timer);
+                resolve();
+            }
+        });
+    });
+}
 describe("process-group", () => {
     it("places the child in its own process group (pid === pgid)", async () => {
         if (process.platform === "win32")
@@ -28,15 +50,13 @@ describe("process-group", () => {
             return;
         const proc = spawnInGroup(process.execPath, [
             "-e",
-            "process.on('SIGINT', () => process.exit(0)); setInterval(()=>{}, 1000);",
+            "process.on('SIGINT', () => process.exit(0)); process.stdout.write('ready\\n'); setInterval(()=>{}, 1000);",
         ]);
         // Capture the exit state up front so we never miss it.
         const exited = new Promise((resolve) => {
             proc.once("exit", (code, signal) => resolve({ code, signal }));
         });
-        // Give the child enough time to attach its SIGINT handler even
-        // under contention (9 parallel test files, git spawning, etc.).
-        await new Promise((r) => setTimeout(r, 500));
+        await waitForReady(proc);
         await terminateGroup(proc, {
             sigintTimeoutMs: 2000,
             sigtermTimeoutMs: 500,
@@ -52,17 +72,17 @@ describe("process-group", () => {
             return;
         const proc = spawnInGroup(process.execPath, [
             "-e",
-            "process.on('SIGINT', () => {}); process.on('SIGTERM', () => {}); setInterval(()=>{}, 1000);",
+            "process.on('SIGINT', () => {}); process.on('SIGTERM', () => {}); process.stdout.write('ready\\n'); setInterval(()=>{}, 1000);",
         ]);
         const exited = new Promise((resolve) => {
             proc.once("exit", (code, signal) => resolve({ code, signal }));
         });
-        await new Promise((r) => setTimeout(r, 150));
+        await waitForReady(proc);
         await terminateGroup(proc, {
             sigintTimeoutMs: 200,
             sigtermTimeoutMs: 200,
         });
         const result = await exited;
-        expect(result.signal === "SIGKILL" || result.code !== null).toBe(true);
+        expect(result.signal).toBe("SIGKILL");
     });
 });

package/dist/__tests__/stream-parser-selftest.test.d.ts

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

package/dist/__tests__/stream-parser-selftest.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it, vi } from "vitest";
+import { StreamParser } from "../stream-parser.js";
+import { verifyStreamParserFormat } from "../stream-parser-selftest.js";
+describe("verifyStreamParserFormat", () => {
+    it("passes with the current stream-parser implementation", () => {
+        expect(() => verifyStreamParserFormat()).not.toThrow();
+    });
+    it("throws a descriptive error if the parser is silently broken", () => {
+        // Simulate CLI-format drift: stub StreamParser so `feed` is a no-op.
+        // The canary should notice that no events fired and fail loud.
+        const spy = vi
+            .spyOn(StreamParser.prototype, "feed")
+            .mockImplementation(() => {
+            // drop every line
+        });
+        try {
+            expect(() => verifyStreamParserFormat()).toThrow(/canary failed/i);
+        }
+        finally {
+            spy.mockRestore();
+        }
+    });
+});

package/dist/__tests__/stream-parser.test.d.ts

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

package/dist/__tests__/stream-parser.test.js

@@ -0,0 +1,199 @@
+import { describe, expect, it } from "vitest";
+import { StreamParser } from "../stream-parser.js";
+function collect(parser) {
+    const texts = [];
+    const toolStarts = [];
+    const toolEnds = [];
+    const results = [];
+    const costs = [];
+    const errors = [];
+    parser.on("text", (c) => texts.push(c));
+    parser.on("tool_start", (name, input) => toolStarts.push({ name, input }));
+    parser.on("tool_end", (name, id, content) => toolEnds.push({ name, id, content }));
+    parser.on("result", (stop) => results.push(stop));
+    parser.on("cost_update", (c) => costs.push(c));
+    parser.on("parse_error", (m) => errors.push(m));
+    return { texts, toolStarts, toolEnds, results, costs, errors };
+}
+describe("StreamParser", () => {
+    it("emits text from assistant content blocks (Claude CLI stream-json format)", () => {
+        const parser = new StreamParser();
+        const events = collect(parser);
+        parser.feed(`${JSON.stringify({
+            type: "assistant",
+            message: {
+                content: [
+                    {
+                        type: "text",
+                        text: '```json\n{"verdict":"approved","summary":"ok"}\n```',
+                    },
+                ],
+            },
+        })}\n`);
+        expect(events.texts).toHaveLength(1);
+        expect(events.texts[0]).toContain('"verdict":"approved"');
+    });
+    it("emits tool_start for tool_use blocks and tool_end for tool_result with matching name", () => {
+        const parser = new StreamParser();
+        const events = collect(parser);
+        parser.feed(`${JSON.stringify({
+            type: "assistant",
+            message: {
+                content: [
+                    {
+                        type: "tool_use",
+                        id: "toolu_1",
+                        name: "Bash",
+                        input: { command: "ls" },
+                    },
+                ],
+            },
+        })}\n`);
+        parser.feed(`${JSON.stringify({
+            type: "user",
+            message: {
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: "toolu_1",
+                        content: "file1\nfile2",
+                    },
+                ],
+            },
+        })}\n`);
+        expect(events.toolStarts).toEqual([
+            { name: "Bash", input: { command: "ls" } },
+        ]);
+        expect(events.toolEnds).toEqual([
+            { name: "Bash", id: "toolu_1", content: "file1\nfile2" },
+        ]);
+    });
+    it("ignores thinking blocks", () => {
+        const parser = new StreamParser();
+        const events = collect(parser);
+        parser.feed(`${JSON.stringify({
+            type: "assistant",
+            message: {
+                content: [
+                    { type: "thinking", thinking: "pondering..." },
+                    { type: "text", text: "actual output" },
+                ],
+            },
+        })}\n`);
+        expect(events.texts).toEqual(["actual output"]);
+    });
+    it("falls back to result.result when no assistant text was streamed", () => {
+        const parser = new StreamParser();
+        const events = collect(parser);
+        parser.feed(`${JSON.stringify({
+            type: "result",
+            subtype: "success",
+            result: "final verdict text",
+            total_cost_usd: 0.5,
+            usage: {
+                input_tokens: 10,
+                output_tokens: 20,
+                cache_read_input_tokens: 100,
+                cache_creation_input_tokens: 5,
+            },
+            duration_ms: 1000,
+            duration_api_ms: 900,
+            num_turns: 3,
+        })}\n`);
+        expect(events.texts).toEqual(["final verdict text"]);
+        expect(events.costs).toEqual([
+            {
+                totalCostUsd: 0.5,
+                totalInputTokens: 10,
+                totalOutputTokens: 20,
+                totalCacheCreationInputTokens: 5,
+                totalCacheReadInputTokens: 100,
+                durationMs: 1000,
+                durationApiMs: 900,
+                numTurns: 3,
+                modelName: undefined,
+            },
+        ]);
+        expect(events.results).toEqual(["success"]);
+    });
+    it("does NOT duplicate text from result.result when assistant text was already emitted", () => {
+        const parser = new StreamParser();
+        const events = collect(parser);
+        parser.feed(`${JSON.stringify({
+            type: "assistant",
+            message: {
+                content: [{ type: "text", text: "the verdict" }],
+            },
+        })}\n${JSON.stringify({
+            type: "result",
+            subtype: "success",
+            result: "the verdict",
+            total_cost_usd: 0,
+        })}\n`);
+        expect(events.texts).toEqual(["the verdict"]);
+    });
+    it("handles split NDJSON chunks (partial line buffering)", () => {
+        const parser = new StreamParser();
+        const events = collect(parser);
+        const line = JSON.stringify({
+            type: "assistant",
+            message: { content: [{ type: "text", text: "hello" }] },
+        });
+        parser.feed(line.slice(0, 20));
+        parser.feed(`${line.slice(20)}\n`);
+        expect(events.texts).toEqual(["hello"]);
+    });
+    it("handles tool_result content as array of blocks", () => {
+        const parser = new StreamParser();
+        const events = collect(parser);
+        parser.feed(`${JSON.stringify({
+            type: "assistant",
+            message: {
+                content: [{ type: "tool_use", id: "t1", name: "Read", input: {} }],
+            },
+        })}\n${JSON.stringify({
+            type: "user",
+            message: {
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: "t1",
+                        content: [{ type: "text", text: "line1" }],
+                    },
+                ],
+            },
+        })}\n`);
+        expect(events.toolEnds[0].content).toBe("line1");
+    });
+    it("skips non-JSON lines silently (no parse_error event)", () => {
+        const parser = new StreamParser();
+        const events = collect(parser);
+        parser.feed("not-json garbage\n");
+        parser.feed(`${JSON.stringify({
+            type: "assistant",
+            message: { content: [{ type: "text", text: "ok" }] },
+        })}\n`);
+        expect(events.errors).toHaveLength(0);
+        expect(events.texts).toEqual(["ok"]);
+    });
+    it("throws if attached twice", async () => {
+        const parser = new StreamParser();
+        const { Readable } = await import("node:stream");
+        parser.attach(Readable.from([]));
+        expect(() => parser.attach(Readable.from([]))).toThrow("StreamParser already attached");
+    });
+    it("reconstructs the full verdict JSON across multiple streamed text blocks", () => {
+        // Simulates the common case where Claude streams a final message with
+        // a preamble + fenced JSON block in a single text block. The StreamParser
+        // MUST surface that text so parseReviewOutput can pick up the verdict.
+        const parser = new StreamParser();
+        const events = collect(parser);
+        const finalText = 'All findings complete. Outputting verdict.\n\n```json\n{\n  "verdict": "approved",\n  "summary": "ok",\n  "findings": []\n}\n```';
+        parser.feed(`${JSON.stringify({
+            type: "assistant",
+            message: { content: [{ type: "text", text: finalText }] },
+        })}\n`);
+        const joined = events.texts.join("");
+        expect(joined).toContain('"verdict": "approved"');
+    });
+});

package/dist/completion.d.ts

@@ -12,10 +12,16 @@ export declare function buildTokenPayload(stats?: SessionStats | null): {
     costCents?: undefined;
     inputTokens?: undefined;
     outputTokens?: undefined;
+    cacheCreationInputTokens?: undefined;
+    cacheReadInputTokens?: undefined;
+    modelName?: undefined;
 } | {
     costCents: number;
     inputTokens: number;
     outputTokens: number;
+    cacheCreationInputTokens: number;
+    cacheReadInputTokens: number;
+    modelName: string | undefined;
 };
 /**
  * Post-work pipeline: push branch, create PR, move card, post summary.

package/dist/completion.js

@@ -20,6 +20,9 @@ export function buildTokenPayload(stats) {
         costCents: Math.round(stats.cost.totalCostUsd * 100),
         inputTokens: stats.cost.totalInputTokens,
         outputTokens: stats.cost.totalOutputTokens,
+        cacheCreationInputTokens: stats.cost.totalCacheCreationInputTokens,
+        cacheReadInputTokens: stats.cost.totalCacheReadInputTokens,
+        modelName: stats.cost.modelName,
     };
 }
 /**
@@ -140,11 +143,18 @@ async function postSummary(client, card, branchName, worktreePath, prUrl, baseBr
         if (sessionStats.cost) {
             statParts.push(`$${sessionStats.cost.totalCostUsd.toFixed(2)} cost`);
             statParts.push(`${sessionStats.cost.numTurns} turns`);
-            const totalTokens = sessionStats.cost.totalInputTokens +
-                sessionStats.cost.totalOutputTokens;
+            const totalInput = sessionStats.cost.totalInputTokens +
+                sessionStats.cost.totalCacheCreationInputTokens +
+                sessionStats.cost.totalCacheReadInputTokens;
+            const totalTokens = totalInput + sessionStats.cost.totalOutputTokens;
             if (totalTokens > 0) {
                 statParts.push(`${formatTokenCount(totalTokens)} tokens`);
             }
+            const cacheRead = sessionStats.cost.totalCacheReadInputTokens;
+            if (totalInput > 0 && cacheRead > 0) {
+                const hitPct = Math.round((cacheRead / totalInput) * 100);
+                statParts.push(`${hitPct}% cache hit`);
+            }
         }
         parts.push(`Stats: ${statParts.join(" · ")}`);
     }

package/dist/index.js

@@ -1,5 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
 import { buildLabelMap, hasLabel, resolveCardLabels } from "./board-helpers.js";
 import { createApiClient, fetchRealtimeCredentials, loadDaemonConfig, } from "./config.js";
 import { ConfigValidationError, validateColumnReferences, } from "./config-validation.js";
@@ -12,9 +13,12 @@ import { Reconciler } from "./reconcile.js";
 import { recoverOrphans } from "./recovery.js";
 import { extractBranchFromDescription } from "./review-worktree.js";
 import { StateStore } from "./state-store.js";
+import { verifyStreamParserFormat } from "./stream-parser-selftest.js";
+import { AGENT_NAME } from "./types.js";
 import { Watcher } from "./watcher.js";
 import { WorktreeGc } from "./worktree-gc.js";
 const TAG = "daemon";
+const { version: PKG_VERSION } = createRequire(import.meta.url)("../package.json");
 // ============ STARTUP VALIDATION ============
 async function validatePrerequisites(config) {
     // 1. Check claude CLI
@@ -27,6 +31,10 @@ async function validatePrerequisites(config) {
     catch {
         throw new Error("Claude CLI not found. Install it: https://docs.anthropic.com/en/docs/claude-code");
     }
+    // 1b. Stream parser canary — if the CLI stream-json envelope has drifted,
+    // every review would silently park with a parse error (see #128).
+    verifyStreamParserFormat();
+    log.info(TAG, "Stream parser canary: ok");
     // 2. Check git provider CLI (if PR creation enabled in either pipeline)
     if (config.agent.completion.createPR || config.agent.review.createPR) {
         const provider = detectGitProvider();
@@ -79,7 +87,7 @@ async function validatePrerequisites(config) {
 // ============ MAIN DAEMON ============
 export { validatePrerequisites };
 export async function main() {
-    log.info(TAG, "Harmony Agent Daemon starting...");
+    log.info(TAG, `Harmony Agent Daemon v${PKG_VERSION} starting...`);
     // Load config
     const config = loadDaemonConfig();
     log.info(TAG, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Model: ${config.agent.claude.model} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
@@ -193,7 +201,12 @@ export async function main() {
         })
         : null;
     // Create watcher (broadcast events from harmony-api + agent commands from UI)
-    const watcher = new Watcher(realtimeCreds, config.projectId, async (event) => {
+    const watcher = new Watcher(realtimeCreds, config.projectId, {
+        userId: agentUserId,
+        userEmail: config.userEmail,
+        agentIdentifier: "harmony-daemon",
+        agentName: AGENT_NAME,
+    }, async (event) => {
         await handleBroadcast(event, client, pool, config, agentUserId);
     }, async (command) => {
         await pool.handleAgentCommand(command.cardId, command.command);

package/dist/merge-monitor.js

@@ -134,20 +134,23 @@ export class MergeMonitor {
                 log.warn(TAG, `Failed to remove label: ${err instanceof Error ? err.message : err}`);
             }
         }
-        // 4. Mark done + append merge timestamp to description (idempotent)
+        // 4. Append merge timestamp to description (idempotent).
+        // Do NOT force done=true here — the column's `mark_cards_done` flag is the
+        // user's source of truth, and the backend `moveCard` in step 1 already
+        // applied it. Overriding here would ignore the user's column setting (#129).
         const existing = card.description || "";
         const alreadyStamped = existing.includes("Merged at");
-        try {
-            const update = { done: true };
-            if (!alreadyStamped) {
+        if (!alreadyStamped) {
+            try {
                 const timestamp = new Date().toISOString();
                 const separator = existing ? "\n" : "";
-                update.description = `${existing}${separator}Merged at ${timestamp}`;
+                await this.client.updateCard(card.id, {
+                    description: `${existing}${separator}Merged at ${timestamp}`,
+                });
+            }
+            catch (err) {
+                log.warn(TAG, `Failed to update card: ${err instanceof Error ? err.message : err}`);
             }
-            await this.client.updateCard(card.id, update);
-        }
-        catch (err) {
-            log.warn(TAG, `Failed to update card: ${err instanceof Error ? err.message : err}`);
         }
         // 5. Best-effort: clean up local branch (uses shared extraction with validation)
         const branchName = extractBranchFromDescription(card.description);

package/dist/progress-tracker.js

@@ -349,6 +349,9 @@ export class ProgressTracker {
             costCents: Math.round((this.lastCost?.totalCostUsd ?? 0) * 100),
             inputTokens: this.lastCost?.totalInputTokens ?? 0,
             outputTokens: this.lastCost?.totalOutputTokens ?? 0,
+            cacheCreationInputTokens: this.lastCost?.totalCacheCreationInputTokens ?? 0,
+            cacheReadInputTokens: this.lastCost?.totalCacheReadInputTokens ?? 0,
+            modelName: this.lastCost?.modelName,
         })
             .catch((err) => {
             log.warn(TAG, `Failed to send progress update: ${err}`);

package/dist/review-completion.d.ts

@@ -36,4 +36,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): Promise<void>;
+export declare function runReviewCompletion(client: HarmonyApiClient, card: Card, result: ReviewResult, config: AgentConfig, worktreePath: string, branchName: string | null, sessionStats?: SessionStats | null, runLogPath?: string | null): Promise<void>;

package/dist/review-completion.js

@@ -1,3 +1,4 @@
+import { readFileSync, statSync } from "node:fs";
 import { addLabelByName, moveCardToColumn } from "./board-helpers.js";
 import { buildTokenPayload } from "./completion.js";
 import { createPullRequest, detectGitProvider, pushBranch } from "./git-pr.js";
@@ -7,6 +8,24 @@ import { cleanupWorktree } from "./worktree.js";
 const TAG = "review-completion";
 const MAX_FINDINGS = 10;
 const REVIEW_MARKER = "---\n**Review:";
+const RUN_LOG_TAIL_BYTES = 2048;
+/**
+ * Read the last N bytes of a file as UTF-8. Returns null on any IO failure —
+ * the parse-error surfacing is best-effort diagnostic, it must not throw.
+ */
+function tailRunLog(path, bytes = RUN_LOG_TAIL_BYTES) {
+    try {
+        const size = statSync(path).size;
+        if (size === 0)
+            return null;
+        const start = Math.max(0, size - bytes);
+        const buf = readFileSync(path);
+        return buf.subarray(start).toString("utf-8");
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Extract structured fields from a parsed JSON object into a ReviewResult.
  */
@@ -163,7 +182,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, sessionStats) {
+export async function runReviewCompletion(client, card, result, config, worktreePath, branchName, sessionStats, runLogPath) {
     // Re-fetch card for fresh description (avoids stale data from enqueue time)
     let freshDesc;
     try {
@@ -189,10 +208,24 @@ export async function runReviewCompletion(client, card, result, config, worktree
         }
         if (config.review.postFindings) {
             const baseDesc = stripReviewSummary(freshDesc);
+            const rawTail = runLogPath ? tailRunLog(runLogPath) : null;
+            // Log content routinely contains ```json fences from Claude's own
+            // output; embedding it inside a 3-backtick fence would break the card's
+            // markdown. Use a 4-backtick fence and downgrade any 4+-backtick runs.
+            const runLogTail = rawTail
+                ? rawTail.replace(/`{4,}/g, (_m) => "`".repeat(3))
+                : null;
+            const runLogHint = runLogPath
+                ? `\nRun log: \`${runLogPath}\``
+                : "\nRun log: (not captured)";
             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.',
+                '\nThe review agent\'s output could not be parsed. Card stays in Review with the "Need Review" label — inspect the run log below to diagnose.',
+                runLogHint,
                 result.summary ? `\n\nRaw output (truncated):\n${result.summary}` : "",
+                runLogTail
+                    ? `\n\nRun log tail (last ${RUN_LOG_TAIL_BYTES}B):\n\`\`\`\`\n${runLogTail}\n\`\`\`\``
+                    : "",
             ].join("");
             try {
                 await client.updateCard(card.id, { description: baseDesc + summary });

package/dist/review-worker.d.ts

@@ -21,6 +21,7 @@ export declare class ReviewWorker {
     private lastSessionStats;
     private aborted;
     private runId;
+    private lastRunLogPath;
     constructor(id: number, config: AgentConfig, client: HarmonyApiClient, _userEmail: string, onDone: (worker: ReviewWorker) => void, stateStore: StateStore);
     private startHeartbeat;
     private stopHeartbeat;

package/dist/review-worker.js

@@ -36,6 +36,7 @@ export class ReviewWorker {
     lastSessionStats = null;
     aborted = false;
     runId = null;
+    lastRunLogPath = null;
     constructor(id, config, client, _userEmail, onDone, stateStore) {
         this.config = config;
         this.client = client;
@@ -255,7 +256,7 @@ export class ReviewWorker {
                 progressPercent: 80,
             });
             // Run review completion pipeline
-            await runReviewCompletion(this.client, card, result, this.config, cwd, this.branchName, sessionStats);
+            await runReviewCompletion(this.client, card, result, this.config, cwd, this.branchName, sessionStats, this.lastRunLogPath);
         }
         catch (err) {
             this.state = "error";
@@ -439,6 +440,7 @@ export class ReviewWorker {
             ];
             log.info(this.tag, `Spawning review: claude ${args.slice(0, 5).join(" ")} ...`);
             const runLog = openRunLog(this.tag, this.runId, shortId);
+            this.lastRunLogPath = runLog?.path ?? null;
             if (runLog) {
                 log.info(this.tag, `Run log: ${runLog.path}`);
                 runLog.stream.write(`# run=${this.runId} card=#${shortId} pipeline=review started=${new Date().toISOString()}\n` +

package/dist/stream-parser-selftest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Feed a minimal Claude-CLI stream-json fixture through StreamParser and
+ * assert the expected events fire. Intended as a startup canary: if the CLI
+ * ever changes its envelope shape, the daemon fails loud on boot instead of
+ * silently parking every card with a parse error (see card #128).
+ *
+ * Throws on any missing event; returns silently on success.
+ */
+export declare function verifyStreamParserFormat(): void;

package/dist/stream-parser-selftest.js

@@ -0,0 +1,97 @@
+import { StreamParser } from "./stream-parser.js";
+/**
+ * Feed a minimal Claude-CLI stream-json fixture through StreamParser and
+ * assert the expected events fire. Intended as a startup canary: if the CLI
+ * ever changes its envelope shape, the daemon fails loud on boot instead of
+ * silently parking every card with a parse error (see card #128).
+ *
+ * Throws on any missing event; returns silently on success.
+ */
+export function verifyStreamParserFormat() {
+    const parser = new StreamParser();
+    let textSeen = null;
+    let toolStart = null;
+    let toolEnd = null;
+    let resultSeen = null;
+    let costSeen = false;
+    parser.on("text", (c) => {
+        textSeen = c;
+    });
+    parser.on("tool_start", (name, input) => {
+        toolStart = { name, input };
+    });
+    parser.on("tool_end", (name, id, content) => {
+        toolEnd = { name, id, content };
+    });
+    parser.on("result", (stop) => {
+        resultSeen = stop;
+    });
+    parser.on("cost_update", () => {
+        costSeen = true;
+    });
+    const fixture = [
+        {
+            type: "assistant",
+            message: {
+                content: [{ type: "text", text: "canary-text" }],
+            },
+        },
+        {
+            type: "assistant",
+            message: {
+                content: [
+                    { type: "tool_use", id: "tu_canary", name: "Read", input: { x: 1 } },
+                ],
+            },
+        },
+        {
+            type: "user",
+            message: {
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: "tu_canary",
+                        content: "ok",
+                    },
+                ],
+            },
+        },
+        {
+            type: "result",
+            subtype: "success",
+            result: "done",
+            stop_reason: "end_turn",
+            total_cost_usd: 0.001,
+            usage: { input_tokens: 1, output_tokens: 1 },
+        },
+    ];
+    for (const line of fixture) {
+        parser.feed(`${JSON.stringify(line)}\n`);
+    }
+    const failures = [];
+    if (textSeen !== "canary-text") {
+        failures.push(`text event missing or wrong (got ${JSON.stringify(textSeen)})`);
+    }
+    const ts = toolStart;
+    if (!ts || ts.name !== "Read") {
+        failures.push("tool_start event missing or wrong");
+    }
+    const te = toolEnd;
+    if (!te ||
+        te.name !== "Read" ||
+        te.id !== "tu_canary" ||
+        te.content !== "ok") {
+        failures.push("tool_end event missing or wrong");
+    }
+    if (resultSeen !== "end_turn") {
+        failures.push(`result event missing or wrong (got ${JSON.stringify(resultSeen)})`);
+    }
+    if (!costSeen) {
+        failures.push("cost_update event missing");
+    }
+    if (failures.length > 0) {
+        throw new Error("StreamParser canary failed — Claude CLI stream-json format may have drifted. " +
+            "Review pipeline will silently park every card until this is fixed.\n" +
+            failures.map((f) => `  - ${f}`).join("\n"));
+    }
+}

package/dist/stream-parser.d.ts

@@ -2,11 +2,15 @@ import { EventEmitter } from "node:events";
 import type { Readable } from "node:stream";
 export interface CostUpdate {
     totalCostUsd: number;
+    /** Fresh input tokens only — does NOT include cache_read or cache_creation. */
     totalInputTokens: number;
     totalOutputTokens: number;
+    totalCacheCreationInputTokens: number;
+    totalCacheReadInputTokens: number;
     durationMs: number;
     durationApiMs: number;
     numTurns: number;
+    modelName?: string;
 }
 export interface StreamParserEvents {
     tool_start: [name: string, input: unknown];
@@ -19,12 +23,20 @@ export interface StreamParserEvents {
 export declare class StreamParser extends EventEmitter<StreamParserEvents> {
     private buffer;
     private attached;
+    private toolNames;
+    private hasEmittedText;
+    private observedModel?;
     /**
      * Attach a readable stream (Claude CLI stdout) to the parser.
      * Parses NDJSON lines and emits typed events.
      * Each instance must only be attached once.
      */
     attach(stream: Readable): void;
+    /**
+     * Feed a raw NDJSON chunk directly. Exposed for tests and any caller
+     * that doesn't have a Readable stream handy.
+     */
+    feed(chunk: string): void;
     private flush;
     private parseLine;
     private handleMessage;

package/dist/stream-parser.js

@@ -4,6 +4,9 @@ const TAG = "stream-parser";
 export class StreamParser extends EventEmitter {
     buffer = "";
     attached = false;
+    toolNames = new Map();
+    hasEmittedText = false;
+    observedModel;
     /**
      * Attach a readable stream (Claude CLI stdout) to the parser.
      * Parses NDJSON lines and emits typed events.
@@ -25,6 +28,14 @@ export class StreamParser extends EventEmitter {
             }
         });
     }
+    /**
+     * Feed a raw NDJSON chunk directly. Exposed for tests and any caller
+     * that doesn't have a Readable stream handy.
+     */
+    feed(chunk) {
+        this.buffer += chunk;
+        this.flush();
+    }
     flush() {
         const lines = this.buffer.split("\n");
         // Keep incomplete last line in buffer
@@ -56,40 +67,108 @@ export class StreamParser extends EventEmitter {
         }
     }
     handleMessage(msg) {
+        // Capture model from any envelope that carries it. The Claude CLI exposes
+        // `model` on the top-level `system` envelope and inside each assistant
+        // envelope's message, but the final `result` envelope does not.
+        if (!this.observedModel) {
+            if (typeof msg.model === "string") {
+                this.observedModel = msg.model;
+            }
+            else if (typeof msg.message?.model === "string") {
+                this.observedModel = msg.message.model;
+            }
+        }
         switch (msg.type) {
             case "assistant": {
-                if (msg.subtype === "tool_use" && msg.tool_name) {
-                    this.emit("tool_start", msg.tool_name, msg.input);
-                }
-                else if (msg.subtype === "text" && msg.content) {
-                    this.emit("text", msg.content);
+                const blocks = msg.message?.content;
+                if (!Array.isArray(blocks))
+                    break;
+                for (const block of blocks) {
+                    if (block.type === "text" && typeof block.text === "string") {
+                        this.emit("text", block.text);
+                        this.hasEmittedText = true;
+                    }
+                    else if (block.type === "tool_use" &&
+                        typeof block.name === "string") {
+                        if (typeof block.id === "string") {
+                            this.toolNames.set(block.id, block.name);
+                        }
+                        this.emit("tool_start", block.name, block.input);
+                    }
+                    // thinking blocks, redacted_thinking, etc. — ignored
                 }
                 break;
             }
-            case "tool_result": {
-                if (msg.tool_use_id && msg.tool_name) {
-                    this.emit("tool_end", msg.tool_name, msg.tool_use_id, msg.content);
+            case "user": {
+                const blocks = msg.message?.content;
+                if (!Array.isArray(blocks))
+                    break;
+                for (const block of blocks) {
+                    if (block.type === "tool_result" &&
+                        typeof block.tool_use_id === "string") {
+                        const name = this.toolNames.get(block.tool_use_id) ?? "";
+                        this.toolNames.delete(block.tool_use_id);
+                        const content = normalizeToolResultContent(block.content);
+                        this.emit("tool_end", name, block.tool_use_id, content);
+                    }
                 }
                 break;
             }
             case "result": {
-                this.emit("result", msg.stop_reason ?? "unknown");
-                break;
-            }
-            case "cost_update": {
-                if (msg.total_cost_usd != null) {
+                // Fallback: if the CLI ended without streaming any assistant text
+                // (e.g. hit max-turns), the final `result` field still carries the
+                // last assistant message. Emit it so the caller can parse the verdict.
+                if (!this.hasEmittedText &&
+                    typeof msg.result === "string" &&
+                    msg.result.length > 0) {
+                    this.emit("text", msg.result);
+                    this.hasEmittedText = true;
+                }
+                if (typeof msg.total_cost_usd === "number") {
+                    const usage = msg.usage;
                     this.emit("cost_update", {
                         totalCostUsd: msg.total_cost_usd,
-                        totalInputTokens: msg.total_input_tokens ?? 0,
-                        totalOutputTokens: msg.total_output_tokens ?? 0,
+                        totalInputTokens: usage?.input_tokens ?? 0,
+                        totalOutputTokens: usage?.output_tokens ?? 0,
+                        totalCacheCreationInputTokens: usage?.cache_creation_input_tokens ?? 0,
+                        totalCacheReadInputTokens: usage?.cache_read_input_tokens ?? 0,
                         durationMs: msg.duration_ms ?? 0,
                         durationApiMs: msg.duration_api_ms ?? 0,
                         numTurns: msg.num_turns ?? 0,
+                        modelName: this.observedModel ??
+                            (typeof msg.model === "string" ? msg.model : undefined),
                     });
                 }
+                this.emit("result", msg.stop_reason ?? msg.subtype ?? "unknown");
                 break;
             }
             // Ignore system, ping, etc.
         }
     }
 }
+function normalizeToolResultContent(raw) {
+    if (raw == null)
+        return undefined;
+    if (typeof raw === "string")
+        return raw;
+    if (Array.isArray(raw)) {
+        // Anthropic sometimes returns content as a list of typed blocks
+        // ({ type: "text", text: "..." }); flatten text blocks, fall back to JSON.
+        const parts = [];
+        for (const block of raw) {
+            if (block &&
+                typeof block === "object" &&
+                "text" in block &&
+                typeof block.text === "string") {
+                parts.push(block.text);
+            }
+        }
+        return parts.length > 0 ? parts.join("") : JSON.stringify(raw);
+    }
+    try {
+        return JSON.stringify(raw);
+    }
+    catch {
+        return String(raw);
+    }
+}

package/dist/watcher.d.ts

@@ -9,6 +9,12 @@ export interface AgentCommandEvent {
 }
 export type CardBroadcastHandler = (event: CardBroadcastEvent) => void;
 export type AgentCommandHandler = (event: AgentCommandEvent) => void;
+export interface PresenceIdentity {
+    userId: string;
+    userEmail: string;
+    agentIdentifier: string;
+    agentName: string;
+}
 /**
  * Subscribes to Supabase broadcast events on the board channel.
  * The harmony-api broadcasts card_update and card_created events
@@ -17,6 +23,7 @@ export type AgentCommandHandler = (event: AgentCommandEvent) => void;
 export declare class Watcher {
     private credentials;
     private projectId;
+    private identity;
     private onCardBroadcast;
     private onAgentCommand?;
     private channel;
@@ -25,7 +32,7 @@ export declare class Watcher {
     private daemonId;
     private connected;
     get isConnected(): boolean;
-    constructor(credentials: RealtimeCredentials, projectId: string, onCardBroadcast: CardBroadcastHandler, onAgentCommand?: AgentCommandHandler | undefined);
+    constructor(credentials: RealtimeCredentials, projectId: string, identity: PresenceIdentity, onCardBroadcast: CardBroadcastHandler, onAgentCommand?: AgentCommandHandler | undefined);
     start(): Promise<void>;
     stop(): Promise<void>;
 }

package/dist/watcher.js

@@ -10,6 +10,7 @@ const TAG = "watcher";
 export class Watcher {
     credentials;
     projectId;
+    identity;
     onCardBroadcast;
     onAgentCommand;
     channel = null;
@@ -20,9 +21,10 @@ export class Watcher {
     get isConnected() {
         return this.connected;
     }
-    constructor(credentials, projectId, onCardBroadcast, onAgentCommand) {
+    constructor(credentials, projectId, identity, onCardBroadcast, onAgentCommand) {
         this.credentials = credentials;
         this.projectId = projectId;
+        this.identity = identity;
         this.onCardBroadcast = onCardBroadcast;
         this.onAgentCommand = onAgentCommand;
     }
@@ -85,6 +87,10 @@ export class Watcher {
                 await presenceChannel.track({
                     daemonId: this.daemonId,
                     startedAt: new Date().toISOString(),
+                    userId: this.identity.userId,
+                    userEmail: this.identity.userEmail,
+                    agentIdentifier: this.identity.agentIdentifier,
+                    agentName: this.identity.agentName,
                 });
                 log.info(TAG, "Presence tracked on board-presence channel");
             }

package/dist/worktree.js

@@ -15,32 +15,67 @@ export function createWorktree(basePath, baseBranch, branchName) {
     const worktreeDir = resolve(repoRoot, basePath, branchName);
     if (existsSync(worktreeDir)) {
         log.warn(TAG, `Worktree already exists at ${worktreeDir}, cleaning up`);
-        cleanupWorktree(worktreeDir);
+        cleanupWorktree(worktreeDir, branchName);
     }
-    // Fetch latest from remote to ensure base branch is up to date
+    // Prune stale worktree metadata. If a previous daemon crashed or its
+    // worktree dir was deleted externally, git may still think the branch is
+    // checked out, which blocks `git branch -D` and `git worktree add`.
     try {
-        execFileSync("git", ["fetch", "origin", baseBranch], {
+        execFileSync("git", ["worktree", "prune"], {
             cwd: repoRoot,
             stdio: "pipe",
         });
     }
     catch {
-        log.warn(TAG, "Failed to fetch latest — continuing with local state");
+        // non-fatal
     }
-    // Delete stale branch if it exists from a previous run
+    // Fetch latest from remote to ensure base branch is up to date
     try {
-        execFileSync("git", ["branch", "-D", branchName], {
+        execFileSync("git", ["fetch", "origin", baseBranch], {
             cwd: repoRoot,
             stdio: "pipe",
         });
-        log.info(TAG, `Deleted stale branch: ${branchName}`);
     }
     catch {
-        // Branch doesn't exist — that's fine
+        log.warn(TAG, "Failed to fetch latest — continuing with local state");
     }
-    // Create worktree with a new branch based on origin/<baseBranch>
+    // Create worktree with a fresh branch based on origin/<baseBranch>.
+    // `-B` resets the branch if it already exists — agent branches are owned
+    // per-attempt, so starting fresh from origin is the desired behavior.
     log.info(TAG, `Creating worktree: ${worktreeDir} (branch: ${branchName})`);
-    execFileSync("git", ["worktree", "add", "-b", branchName, worktreeDir, `origin/${baseBranch}`], { cwd: repoRoot, stdio: "pipe" });
+    try {
+        execFileSync("git", [
+            "worktree",
+            "add",
+            "-B",
+            branchName,
+            worktreeDir,
+            `origin/${baseBranch}`,
+        ], { cwd: repoRoot, stdio: "pipe" });
+    }
+    catch (err) {
+        // Last-resort recovery: if `-B` still fails (e.g. branch checked out in
+        // another registered worktree), force-delete the branch and retry.
+        const msg = err instanceof Error ? err.message : String(err);
+        log.warn(TAG, `worktree add failed, attempting forced recovery: ${msg}`);
+        try {
+            execFileSync("git", ["branch", "-D", branchName], {
+                cwd: repoRoot,
+                stdio: "pipe",
+            });
+        }
+        catch {
+            // ignore; retry will surface the real error
+        }
+        execFileSync("git", [
+            "worktree",
+            "add",
+            "-B",
+            branchName,
+            worktreeDir,
+            `origin/${baseBranch}`,
+        ], { cwd: repoRoot, stdio: "pipe" });
+    }
     // Install dependencies in the worktree
     log.info(TAG, "Installing dependencies in worktree...");
     try {

package/package.json

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