@gethmy/agent 1.2.0 → 1.3.0

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/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/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/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

@@ -20,8 +20,10 @@ export function createWorktree(basePath, baseBranch, branchName) {
     // 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", ["worktree", "prune"], {
+        execFileSync("git", ["worktree", "prune", "--expire=now"], {
             cwd: repoRoot,
             stdio: "pipe",
         });
@@ -58,6 +60,26 @@ export function createWorktree(basePath, baseBranch, branchName) {
         // 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,
@@ -112,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.2.0",
+  "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",