@gethmy/agent 1.1.2 → 1.3.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/cli.js

@@ -117,10 +117,14 @@ async function healthCommand() {
 async function doctorCommand() {
     const { loadDaemonConfig } = await import("./config.js");
     const { validatePrerequisites } = await import("./index.js");
+    const { createStartupBanner } = await import("./startup-banner.js");
+    const { createRequire } = await import("node:module");
+    const { version } = createRequire(import.meta.url)("../package.json");
     try {
         const config = loadDaemonConfig();
-        const userId = await validatePrerequisites(config);
-        process.stdout.write(`all checks passed — agent user: ${userId}\n`);
+        const banner = createStartupBanner(config, version);
+        const userId = await validatePrerequisites(config, banner);
+        await banner.ready(`preflight ok — agent user ${userId}`);
         return 0;
     }
     catch (err) {

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/config-validation.d.ts

@@ -16,3 +16,8 @@ export declare class ConfigValidationError extends Error {
  * board before the daemon is useful.
  */
 export declare function validateColumnReferences(client: HarmonyApiClient, projectId: string, config: AgentConfig): Promise<void>;
+/**
+ * Same checks as validateColumnReferences but returns the unique list of
+ * validated column names (used by the startup banner). Throws on mismatch.
+ */
+export declare function validateAndListColumns(client: HarmonyApiClient, projectId: string, config: AgentConfig): Promise<string[]>;

package/dist/config-validation.js

@@ -1,5 +1,3 @@
-import { log } from "./log.js";
-const TAG = "config-validation";
 export class ConfigValidationError extends Error {
     issues;
     constructor(message, issues) {
@@ -60,7 +58,20 @@ export async function validateColumnReferences(client, projectId, config) {
         const help = `Available columns: ${known.join(", ")}`;
         throw new ConfigValidationError(`Invalid agent config — the following columns are missing:\n  - ${issues.join("\n  - ")}\n${help}`, issues);
     }
-    log.info(TAG, `Validated columns: ${Array.from(new Set(required.map((r) => r.value)))
-        .filter(Boolean)
-        .join(", ")}`);
+}
+/**
+ * Same checks as validateColumnReferences but returns the unique list of
+ * validated column names (used by the startup banner). Throws on mismatch.
+ */
+export async function validateAndListColumns(client, projectId, config) {
+    await validateColumnReferences(client, projectId, config);
+    const names = [
+        ...config.pickupColumns,
+        config.completion.moveToColumn,
+        config.verification.failColumn,
+    ];
+    if (config.review.enabled) {
+        names.push(...config.review.pickupColumns, config.review.moveToColumn, config.review.failColumn);
+    }
+    return Array.from(new Set(names.filter(Boolean)));
 }

package/dist/http-server.js

@@ -30,7 +30,6 @@ export class HttpServer {
             });
             this.server.once("error", reject);
             this.server.listen(this.opts.port, this.opts.bindAddr, () => {
-                log.info(TAG, `listening on http://${this.opts.bindAddr}:${this.opts.port}`);
                 resolve();
             });
         });

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { type DaemonConfig } from "./config.js";
-declare function validatePrerequisites(config: DaemonConfig): Promise<string>;
+import { type StartupBanner } from "./startup-banner.js";
+declare function validatePrerequisites(config: DaemonConfig, banner: StartupBanner): Promise<string>;
 export { validatePrerequisites };
 export declare function main(): Promise<void>;

package/dist/index.js

@@ -3,7 +3,7 @@ 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";
+import { ConfigValidationError, validateAndListColumns, } from "./config-validation.js";
 import { detectGitProvider, validateGitProviderCli } from "./git-pr.js";
 import { HttpServer } from "./http-server.js";
 import { log } from "./log.js";
@@ -12,6 +12,7 @@ import { Pool } from "./pool.js";
 import { Reconciler } from "./reconcile.js";
 import { recoverOrphans } from "./recovery.js";
 import { extractBranchFromDescription } from "./review-worktree.js";
+import { createStartupBanner } from "./startup-banner.js";
 import { StateStore } from "./state-store.js";
 import { verifyStreamParserFormat } from "./stream-parser-selftest.js";
 import { AGENT_NAME } from "./types.js";
@@ -20,13 +21,13 @@ 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) {
+async function validatePrerequisites(config, banner) {
     // 1. Check claude CLI
     try {
         const ver = execFileSync("claude", ["--version"], {
             encoding: "utf-8",
         }).trim();
-        log.info(TAG, `Claude CLI: ${ver}`);
+        banner.check(`Claude CLI ${ver}`);
     }
     catch {
         throw new Error("Claude CLI not found. Install it: https://docs.anthropic.com/en/docs/claude-code");
@@ -34,11 +35,11 @@ async function validatePrerequisites(config) {
     // 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");
+    banner.check("Stream parser canary");
     // 2. Check git provider CLI (if PR creation enabled in either pipeline)
     if (config.agent.completion.createPR || config.agent.review.createPR) {
         const provider = detectGitProvider();
-        log.info(TAG, `Git provider: ${provider}`);
+        banner.setGitProvider(provider);
         validateGitProviderCli(provider);
     }
     // 3. Check git repo is clean and base branch exists
@@ -47,6 +48,7 @@ async function validatePrerequisites(config) {
             encoding: "utf-8",
         }).trim();
         if (status) {
+            banner.fail();
             log.warn(TAG, `Working directory has uncommitted changes:\n${status}`);
         }
         execFileSync("git", ["rev-parse", "--verify", `origin/${config.agent.worktree.baseBranch}`], {
@@ -61,7 +63,7 @@ async function validatePrerequisites(config) {
     const client = createApiClient(config);
     try {
         await client.listWorkspaces();
-        log.info(TAG, "API key validated");
+        banner.check("API key validated");
     }
     catch (err) {
         throw new Error(`API key validation failed: ${err instanceof Error ? err.message : err}`);
@@ -75,7 +77,8 @@ async function validatePrerequisites(config) {
             .join("\n");
         throw new Error(`Project "${config.projectId}" not found in workspace.\nAvailable projects:\n${available}`);
     }
-    log.info(TAG, `Project validated: ${project.name}`);
+    banner.setProjectName(project.name);
+    banner.check(`Project access (${project.name})`);
     // 6. Resolve the agent user ID from workspace members
     const members = await client.getWorkspaceMembers(config.workspaceId);
     const agentMember = members.members.find((m) => m.email === config.userEmail);
@@ -87,25 +90,24 @@ async function validatePrerequisites(config) {
 // ============ MAIN DAEMON ============
 export { validatePrerequisites };
 export async function main() {
-    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(", ")}`);
-    if (config.agent.review.enabled) {
-        log.info(TAG, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
-    }
+    // Startup banner — collapses 21 INFO lines into a single grouped block
+    // in pretty mode. Falls through to per-line log.info in JSON mode.
+    const banner = createStartupBanner(config, PKG_VERSION);
     // Validate
-    const agentUserId = await validatePrerequisites(config);
-    log.info(TAG, `Agent user: ${config.userEmail} (${agentUserId})`);
+    const agentUserId = await validatePrerequisites(config, banner);
     // Create API client
     const client = createApiClient(config);
     // Fail fast if configured columns don't exist on the board. A stuck
     // card with no log output is worse than a clear startup error.
     try {
-        await validateColumnReferences(client, config.projectId, config.agent);
+        const cols = await validateAndListColumns(client, config.projectId, config.agent);
+        banner.check(`Columns: ${cols.join(", ")}`);
     }
     catch (err) {
         if (err instanceof ConfigValidationError) {
+            banner.fail();
             log.error(TAG, err.message);
             process.exit(1);
         }
@@ -117,12 +119,16 @@ export async function main() {
     const daemonId = randomUUID();
     await stateStore.setDaemon(daemonId, process.pid);
     const outcomes = await recoverOrphans(stateStore, client, config.agent);
-    if (outcomes.length > 0) {
-        log.info(TAG, `recovery: ${outcomes.length} orphan(s) handled, ${outcomes.filter((o) => o.errors.length).length} had errors`);
+    if (outcomes.length === 0) {
+        banner.check("Recovery: no orphans");
+    }
+    else {
+        const errored = outcomes.filter((o) => o.errors.length).length;
+        banner.check(`Recovery: ${outcomes.length} orphan(s) handled${errored > 0 ? `, ${errored} with errors` : ""}`);
     }
     // Fetch realtime credentials
     const realtimeCreds = await fetchRealtimeCredentials(client);
-    log.info(TAG, "Realtime credentials fetched");
+    banner.check("Realtime credentials");
     // Create pool
     const pool = new Pool(config.agent, client, config.userEmail, config.workspaceId, config.projectId, stateStore);
     // Create reconciler
@@ -250,10 +256,44 @@ export async function main() {
             await httpServer.start();
         }
         catch (err) {
+            banner.fail();
             log.warn(TAG, `HTTP server failed to bind: ${err instanceof Error ? err.message : err}`);
         }
     }
-    log.info(TAG, "Daemon is running. Watching for card assignments...");
+    // Banner check lines for service intervals + pool. Compose into one
+    // line each so the banner stays compact.
+    const reviewCount = config.agent.review.enabled ? 1 : 0;
+    banner.check(`Pool: ${config.agent.poolSize} impl${reviewCount > 0 ? ` + ${reviewCount} review` : ""}`);
+    const services = [
+        `Heartbeat ${config.agent.timing.reconcileIntervalMs / 1000}s`,
+    ];
+    if (mergeMonitor) {
+        // MergeMonitor's interval isn't configurable in AgentConfig; matches
+        // its constructor default.
+        services.push("Merge monitor 60s");
+    }
+    services.push(`Worktree GC ${config.agent.timing.worktreeGcIntervalMs / 1000}s`);
+    banner.check(services.join(" · "));
+    // Wait briefly for realtime to fully subscribe so the banner can show
+    // its "✓ Realtime: broadcast + presence" line. If it doesn't arrive in
+    // 3s, the banner shows "✓ Realtime: connecting…" instead and the
+    // watcher's eventual subscribe lines emit normally afterwards.
+    const sleep = (ms) => new Promise((resolve) => setTimeout(() => resolve("timeout"), ms));
+    const winner = await Promise.race([
+        watcher.ready().then(() => "ready"),
+        sleep(3000),
+    ]);
+    if (winner === "ready") {
+        banner.check("Realtime: broadcast + presence");
+    }
+    else {
+        banner.check("Realtime: connecting…");
+    }
+    await banner.ready("watching for card assignments");
+    // Banner has rendered. Allow any realtime events that arrive *after*
+    // the banner's 3 s deadline to log normally — otherwise a slow subscribe
+    // would leave the user with no signal that realtime ever came up.
+    watcher.allowStartupLogs();
 }
 // ============ EVENT HANDLER ============
 async function handleBroadcast(event, client, pool, config, agentUserId) {

package/dist/merge-monitor.js

@@ -29,7 +29,6 @@ export class MergeMonitor {
     }
     start() {
         this.running = true;
-        log.info(TAG, `Merge monitor every ${this.intervalMs / 1000}s`);
         void this.scheduleNext(0);
     }
     stop() {

package/dist/pool.js

@@ -29,8 +29,6 @@ export class Pool {
                 this.tryDispatchFor(this.reviewWorkers, this.reviewQueue, "review");
             }, stateStore));
         }
-        const reviewCount = this.reviewWorkers.length;
-        log.info(TAG, `Pool initialized: ${config.poolSize} impl worker(s), ${reviewCount} review worker(s)`);
     }
     /**
      * Enqueue a card for processing with the given mode.

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/reconcile.js

@@ -40,7 +40,6 @@ export class Reconciler {
         this.agentConfig = agentConfig;
     }
     start() {
-        log.info(TAG, `Heartbeat every ${this.intervalMs / 1000}s`);
         // Run immediately, then on interval
         this.tick();
         this.timer = setInterval(() => this.tick(), this.intervalMs);

package/dist/recovery.js

@@ -44,7 +44,6 @@ async function fetchCardSafely(client, cardId) {
 export async function recoverOrphans(store, client, config) {
     const active = store.getActiveRuns();
     if (active.length === 0) {
-        log.info(TAG, "no orphan runs to recover");
         return [];
     }
     const outcomes = [];

package/dist/review-worktree.js

@@ -19,6 +19,18 @@ export function checkoutExistingBranch(basePath, branchName) {
         log.warn(TAG, `Review worktree already exists at ${worktreeDir}, cleaning up`);
         cleanupWorktree(worktreeDir);
     }
+    // Force-prune orphaned worktree metadata (dir removed externally but git
+    // still registers the branch as checked out). Default expiry is 3 months,
+    // which leaves fresh stale entries in place.
+    try {
+        execFileSync("git", ["worktree", "prune", "--expire=now"], {
+            cwd: repoRoot,
+            stdio: "pipe",
+        });
+    }
+    catch {
+        // non-fatal
+    }
     // Fetch latest to ensure we have the remote branch
     try {
         execFileSync("git", ["fetch", "origin", branchName], {

package/dist/startup-banner.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Startup banner — collapses the ~21 individually-timestamped INFO lines
+ * the daemon used to emit at startup into a single grouped block in
+ * pretty/TTY mode. JSON mode is unchanged (each `check()` falls through
+ * to `log.info("daemon", msg)` so log shippers see the same records).
+ *
+ * Usage:
+ *   const banner = createStartupBanner(config, PKG_VERSION);
+ *   banner.check("Claude CLI 2.1.126");
+ *   banner.setProjectName("Harmony");
+ *   banner.check("API key validated");
+ *   ...
+ *   await banner.ready("watching for card assignments");
+ *
+ * Pretty rendering is deferred until `ready()` so the whole block lands
+ * atomically with one stderr.write — nothing can interleave inside it.
+ * If a startup error occurs and a warn/error needs to fire, call
+ * `banner.fail()` first so the banner suppresses itself and the warning
+ * isn't hidden under the block.
+ */
+import type { DaemonConfig } from "./config.js";
+export interface StartupBanner {
+    setProjectName(name: string): void;
+    setGitProvider(provider: string): void;
+    check(message: string): void;
+    ready(message: string): Promise<void>;
+    fail(): void;
+}
+export declare function createStartupBanner(config: DaemonConfig, version: string): StartupBanner;

package/dist/startup-banner.js

@@ -0,0 +1,143 @@
+import { isPretty, log } from "./log.js";
+const TAG = "daemon";
+const RULE_WIDTH = 70;
+const ANSI = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+};
+export function createStartupBanner(config, version) {
+    return isPretty()
+        ? prettyBanner(config, version)
+        : jsonBanner(config, version);
+}
+function prettyBanner(config, version) {
+    const checks = [];
+    let projectName;
+    let gitProvider;
+    let failed = false;
+    let rendered = false;
+    return {
+        setProjectName(name) {
+            projectName = name;
+        },
+        setGitProvider(provider) {
+            gitProvider = provider;
+        },
+        check(message) {
+            checks.push(message);
+        },
+        fail() {
+            failed = true;
+        },
+        async ready(message) {
+            if (failed || rendered)
+                return;
+            rendered = true;
+            const block = renderPretty({
+                version,
+                config,
+                projectName,
+                gitProvider,
+                checks,
+                readyMessage: message,
+            });
+            process.stderr.write(block);
+        },
+    };
+}
+function jsonBanner(config, version) {
+    // Mirror today's structured output: one log.info per startup event.
+    // Emit the version line eagerly so JSON consumers still see it first.
+    log.info(TAG, `Harmony Agent Daemon v${version} starting...`);
+    log.info(TAG, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Model: ${config.agent.claude.model} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
+    if (config.agent.review.enabled) {
+        log.info(TAG, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
+    }
+    let failed = false;
+    return {
+        setProjectName(_name) {
+            // No-op in JSON mode — the explicit `Project access (X)` check
+            // line that follows already conveys this and avoids duplication.
+        },
+        setGitProvider(provider) {
+            log.info(TAG, `Git provider: ${provider}`);
+        },
+        check(message) {
+            log.info(TAG, message);
+        },
+        fail() {
+            failed = true;
+        },
+        async ready(message) {
+            if (failed)
+                return;
+            log.info(TAG, message);
+        },
+    };
+}
+function renderPretty(input) {
+    const { version, config, projectName, gitProvider, checks, readyMessage } = input;
+    const lines = [];
+    lines.push("");
+    lines.push(titleRule(`Harmony Agent Daemon v${version}`));
+    lines.push("");
+    for (const row of configRows(config, projectName, gitProvider)) {
+        lines.push(`  ${dim(row.label.padEnd(9))} ${row.value}`);
+    }
+    lines.push("");
+    for (const msg of checks) {
+        lines.push(`  ${cyan("✓")} ${msg}`);
+    }
+    lines.push("");
+    lines.push(`${cyan("▶")} ${cyan("Ready")} — ${readyMessage}`);
+    lines.push(dim("─".repeat(RULE_WIDTH)));
+    lines.push("");
+    return lines.join("\n");
+}
+function configRows(config, projectName, gitProvider) {
+    const rows = [];
+    const projectLabel = projectName
+        ? `${projectName} (${shortenId(config.projectId)})`
+        : shortenId(config.projectId);
+    rows.push({ label: "Project", value: projectLabel });
+    rows.push({ label: "User", value: config.userEmail });
+    const reviewEnabled = config.agent.review.enabled;
+    const poolDesc = reviewEnabled
+        ? `Pool ${config.agent.poolSize} impl + 1 review`
+        : `Pool ${config.agent.poolSize} impl`;
+    const flowDesc = reviewEnabled
+        ? `Pickup ${config.agent.pickupColumns[0]} → ${config.agent.completion.moveToColumn} → ${config.agent.review.moveToColumn}`
+        : `Pickup ${config.agent.pickupColumns.join(", ")}`;
+    rows.push({
+        label: "Model",
+        value: `${config.agent.claude.model}  ·  ${poolDesc}  ·  ${flowDesc}`,
+    });
+    const tail = [];
+    if (gitProvider)
+        tail.push(gitProvider);
+    if (config.agent.http.enabled) {
+        tail.push(`HTTP http://${config.agent.http.bindAddr}:${config.agent.http.port}`);
+    }
+    if (tail.length > 0) {
+        rows.push({ label: "Git", value: tail.join("  ·  ") });
+    }
+    return rows;
+}
+function titleRule(title) {
+    const prefix = "─── ";
+    const surround = ` `;
+    const suffix = "─".repeat(Math.max(3, RULE_WIDTH - prefix.length - title.length - surround.length));
+    return dim(`${prefix}${title}${surround}${suffix}`);
+}
+function shortenId(id) {
+    if (id.length <= 8)
+        return id;
+    return `${id.slice(0, 8)}…`;
+}
+function dim(s) {
+    return `${ANSI.dim}${s}${ANSI.reset}`;
+}
+function cyan(s) {
+    return `${ANSI.cyan}${s}${ANSI.reset}`;
+}

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/watcher.d.ts

@@ -31,7 +31,22 @@ export declare class Watcher {
     private supabase;
     private daemonId;
     private connected;
+    private presenceTracked;
+    private suppressStartupLogs;
+    private readyResolve;
+    private readyPromise;
     get isConnected(): boolean;
+    /** Resolves once both broadcast subscription is active AND presence is tracked. */
+    ready(): Promise<void>;
+    /**
+     * Re-enable startup-state log lines. The startup banner suppresses them
+     * by default in pretty mode (it absorbs subscribe/presence into one
+     * "✓ Realtime" line). After the banner has rendered, main() calls this
+     * so any realtime events that arrive *after* the banner — e.g. a slow
+     * subscribe that missed the banner's 3 s deadline — log normally.
+     */
+    allowStartupLogs(): void;
+    private maybeResolveReady;
     constructor(credentials: RealtimeCredentials, projectId: string, identity: PresenceIdentity, onCardBroadcast: CardBroadcastHandler, onAgentCommand?: AgentCommandHandler | undefined);
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/watcher.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { createClient } from "@supabase/supabase-js";
-import { log } from "./log.js";
+import { isPretty, log } from "./log.js";
 const TAG = "watcher";
 /**
  * Subscribes to Supabase broadcast events on the board channel.
@@ -18,9 +18,35 @@ export class Watcher {
     supabase = null;
     daemonId = randomUUID();
     connected = false;
+    presenceTracked = false;
+    suppressStartupLogs = true;
+    readyResolve = null;
+    readyPromise = new Promise((resolve) => {
+        this.readyResolve = resolve;
+    });
     get isConnected() {
         return this.connected;
     }
+    /** Resolves once both broadcast subscription is active AND presence is tracked. */
+    ready() {
+        return this.readyPromise;
+    }
+    /**
+     * Re-enable startup-state log lines. The startup banner suppresses them
+     * by default in pretty mode (it absorbs subscribe/presence into one
+     * "✓ Realtime" line). After the banner has rendered, main() calls this
+     * so any realtime events that arrive *after* the banner — e.g. a slow
+     * subscribe that missed the banner's 3 s deadline — log normally.
+     */
+    allowStartupLogs() {
+        this.suppressStartupLogs = false;
+    }
+    maybeResolveReady() {
+        if (this.connected && this.presenceTracked && this.readyResolve) {
+            this.readyResolve();
+            this.readyResolve = null;
+        }
+    }
     constructor(credentials, projectId, identity, onCardBroadcast, onAgentCommand) {
         this.credentials = credentials;
         this.projectId = projectId;
@@ -29,7 +55,11 @@ export class Watcher {
         this.onAgentCommand = onAgentCommand;
     }
     async start() {
-        log.info(TAG, "Connecting to Supabase realtime (broadcast)...");
+        // In pretty mode the startup banner absorbs realtime readiness into
+        // its "✓ Realtime" line, so this connect message is redundant noise.
+        if (!isPretty()) {
+            log.info(TAG, "Connecting to Supabase realtime (broadcast)...");
+        }
         this.supabase = createClient(this.credentials.supabaseUrl, this.credentials.supabaseAnonKey);
         // Presence channel — separate from the broadcast channel to avoid
         // conflicting with frontend BoardContext's board-{projectId} subscription
@@ -62,7 +92,10 @@ export class Watcher {
             .subscribe((status) => {
             if (status === "SUBSCRIBED") {
                 this.connected = true;
-                log.info(TAG, "Broadcast subscription active");
+                if (!isPretty() || !this.suppressStartupLogs) {
+                    log.info(TAG, "Broadcast subscription active");
+                }
+                this.maybeResolveReady();
             }
             else if (status === "CHANNEL_ERROR") {
                 this.connected = false;
@@ -92,7 +125,11 @@ export class Watcher {
                     agentIdentifier: this.identity.agentIdentifier,
                     agentName: this.identity.agentName,
                 });
-                log.info(TAG, "Presence tracked on board-presence channel");
+                if (!isPretty() || !this.suppressStartupLogs) {
+                    log.info(TAG, "Presence tracked on board-presence channel");
+                }
+                this.presenceTracked = true;
+                this.maybeResolveReady();
             }
         });
         this.presenceChannel = presenceChannel;

package/dist/worktree-gc.js

@@ -78,7 +78,7 @@ export function runWorktreeGc(basePath, store, opts = {}) {
     }
     // Prune any stale metadata leftover from deleted worktrees.
     try {
-        execFileSync("git", ["worktree", "prune"], {
+        execFileSync("git", ["worktree", "prune", "--expire=now"], {
             cwd: repoRoot,
             stdio: "pipe",
         });
@@ -107,7 +107,6 @@ export class WorktreeGc {
         this.intervalMs = intervalMs;
     }
     start() {
-        log.info(TAG, `worktree GC every ${this.intervalMs / 1000}s`);
         // Run once at startup, then on interval.
         this.tick();
         this.timer = setInterval(() => this.tick(), this.intervalMs);

package/dist/worktree.js

@@ -15,32 +15,89 @@ 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`.
+    // `--expire=now` overrides `gc.worktreePruneExpire` (default 3 months) so
+    // freshly-orphaned entries are removed immediately.
     try {
-        execFileSync("git", ["fetch", "origin", baseBranch], {
+        execFileSync("git", ["worktree", "prune", "--expire=now"], {
             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}`);
+        // Remove any registered worktree at this path (phantom or otherwise).
+        try {
+            execFileSync("git", ["worktree", "remove", worktreeDir, "--force"], {
+                cwd: repoRoot,
+                stdio: "pipe",
+            });
+        }
+        catch {
+            // best-effort
+        }
+        // Force-prune any stale worktree admin entries referencing this branch.
+        try {
+            execFileSync("git", ["worktree", "prune", "--expire=now"], {
+                cwd: repoRoot,
+                stdio: "pipe",
+            });
+        }
+        catch {
+            // best-effort
+        }
+        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 {
@@ -77,7 +134,7 @@ export function cleanupWorktree(worktreePath, branchName) {
         }
         // Prune stale worktree entries
         try {
-            execFileSync("git", ["worktree", "prune"], {
+            execFileSync("git", ["worktree", "prune", "--expire=now"], {
                 cwd: repoRoot,
                 stdio: "pipe",
             });

package/package.json

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