@gethmy/agent 1.1.2 → 1.2.0

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.test.js

@@ -104,11 +104,14 @@ describe("StreamParser", () => {
         expect(events.costs).toEqual([
             {
                 totalCostUsd: 0.5,
-                totalInputTokens: 115,
+                totalInputTokens: 10,
                 totalOutputTokens: 20,
+                totalCacheCreationInputTokens: 5,
+                totalCacheReadInputTokens: 100,
                 durationMs: 1000,
                 durationApiMs: 900,
                 numTurns: 3,
+                modelName: undefined,
             },
         ]);
         expect(events.results).toEqual(["success"]);

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/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/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];
@@ -21,6 +25,7 @@ export declare class StreamParser extends EventEmitter<StreamParserEvents> {
     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.

package/dist/stream-parser.js

@@ -6,6 +6,7 @@ export class StreamParser extends EventEmitter {
     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.
@@ -66,6 +67,17 @@ 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": {
                 const blocks = msg.message?.content;
@@ -114,16 +126,17 @@ export class StreamParser extends EventEmitter {
                 }
                 if (typeof msg.total_cost_usd === "number") {
                     const usage = msg.usage;
-                    const totalInputTokens = (usage?.input_tokens ?? 0) +
-                        (usage?.cache_creation_input_tokens ?? 0) +
-                        (usage?.cache_read_input_tokens ?? 0);
                     this.emit("cost_update", {
                         totalCostUsd: msg.total_cost_usd,
-                        totalInputTokens,
+                        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");

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.2",
+  "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",