@scrylog/cli 0.1.4 → 0.3.0

package/src/daemon/collectors/herdr/collector.ts

@@ -0,0 +1,128 @@
+import { listSessions } from "@joeldmtz/prtl-core";
+import type { ListSessionsOptions, PrtlListResult } from "@joeldmtz/prtl-core";
+import type { ScrylogConfig } from "../../../shared/config";
+import type { SessionModel } from "../../../shared/types";
+import type { Logger } from "../../../shared/logger";
+import { NOOP_LOGGER } from "../../../shared/logger";
+import type { Collector } from "../../scheduler";
+import type { DaemonStore } from "../../store";
+import type { GitCollector } from "../git";
+import { herdrPaneToSession } from "./normalization";
+
+type HerdrList = (options?: ListSessionsOptions) => Promise<PrtlListResult>;
+
+export class HerdrCollector implements Collector {
+  name = "herdr";
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private inFlight = false;
+  private generation = 0;
+  private logger: Logger = NOOP_LOGGER;
+
+  constructor(
+    private readonly gitCollector: GitCollector,
+    private readonly list: HerdrList = listSessions,
+  ) {}
+
+  start(store: DaemonStore, config: ScrylogConfig, logger: Logger): void {
+    this.logger = logger;
+    const generation = ++this.generation;
+    const run = () => void this.collect(store, config.daemon.commandTimeoutMs, generation);
+    logger.info("herdr", "Collector started", { event: "collector.started", collector: this.name, intervalMs: config.daemon.pollIntervalMs });
+    run();
+    this.timer = setInterval(run, config.daemon.pollIntervalMs);
+  }
+
+  stop(): void {
+    this.generation += 1;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.logger.info("herdr", "Collector stopped", { event: "collector.stopped", collector: this.name });
+  }
+
+  async collect(store: DaemonStore, timeoutMs: number, generation = this.generation): Promise<void> {
+    if (this.inFlight) {
+      this.logger.debug("herdr", "Skipping overlapping poll", { event: "collector.poll_skipped", collector: this.name });
+      return;
+    }
+
+    this.inFlight = true;
+    const startedAt = Date.now();
+    try {
+      const result = await this.list({ provider: "herdr", timeoutMs });
+      if (generation !== this.generation) return;
+      const provider = result.metadata.providers.herdr;
+      const liveHerdrIds = new Set<string>();
+
+      if (provider?.available) {
+        for (const pane of result.items.filter((item) => item.provider === "herdr")) {
+          const path = pane.foregroundCwd ?? pane.cwd;
+          const session = herdrPaneToSession(pane, path ? this.gitCollector.resolve(path) : undefined);
+          liveHerdrIds.add(session.id);
+          const existing = store.getSession(session.id);
+          if (existing && existing.detectionSource !== "herdr") {
+            if (existing.source !== "tmux") {
+              store.upsertSession({
+                ...existing,
+                source: "herdr",
+                herdr: session.herdr,
+                project: session.project ?? existing.project,
+                currentPath: existing.currentPath ?? session.currentPath,
+                currentCommand: session.currentCommand,
+                paneTitle: session.paneTitle,
+              });
+            }
+          } else {
+            // herdr-native sessions: prtl-core refreshes metadata.collectedAt on
+            // every collection, so a pane doing nothing would report a fresh
+            // lastActivity each poll and constantly reorder idle groups. Only
+            // real changes (state, agent status, summary) count as activity.
+            const previous = existing?.detectionSource === "herdr" ? existing : undefined;
+            const activityChanged = Boolean(
+              previous
+              && (previous.state !== session.state
+                || previous.herdr?.agentStatus !== session.herdr?.agentStatus
+                || previous.summary !== session.summary),
+            );
+            const merged: SessionModel = previous && !activityChanged
+              ? { ...session, lastActivity: previous.lastActivity }
+              : { ...session, lastActivity: Date.now() };
+            store.upsertSession(merged);
+          }
+        }
+
+        for (const session of store.getSessions()) {
+          if (session.source !== "herdr" || liveHerdrIds.has(session.id)) continue;
+          if (session.detectionSource === "herdr") {
+            store.removeSession(session.id);
+          } else {
+            store.clearHerdrBinding(session.id);
+          }
+        }
+      }
+
+      const errors = provider?.errors?.map((error) => `${error.source}: ${error.message}`) ?? [];
+      const lastError = provider?.available ? undefined : (provider?.reason ?? errors.at(-1) ?? "herdr_unavailable");
+      store.setCollectorStatus(this.name, {
+        running: true,
+        lastRunAt: Date.now(),
+        lastDurationMs: Date.now() - startedAt,
+        lastError,
+      });
+      this.logger.debug("herdr", "Collection completed", {
+        event: "collector.poll_completed",
+        collector: this.name,
+        available: provider?.available ?? false,
+        panes: liveHerdrIds.size,
+      });
+    } catch (error) {
+      if (generation !== this.generation) return;
+      const message = error instanceof Error ? error.message : String(error);
+      store.setCollectorStatus(this.name, { running: true, lastRunAt: Date.now(), lastDurationMs: Date.now() - startedAt, lastError: message });
+      this.logger.warn("herdr", "Collection failed", { event: "collector.poll_failed", collector: this.name, errorMessage: message });
+    } finally {
+      this.inFlight = false;
+    }
+  }
+}

package/src/daemon/collectors/herdr/index.ts

@@ -0,0 +1,2 @@
+export { HerdrCollector } from "./collector";
+export { herdrPaneToSession, herdrSessionId, herdrState, herdrSummary, herdrTool } from "./normalization";

package/src/daemon/collectors/herdr/normalization.ts

@@ -0,0 +1,111 @@
+import type { PrtlPane } from "@joeldmtz/prtl-core";
+import type { ProjectInfo, SessionModel, SessionState, SessionTool } from "../../../shared/types";
+
+const SESSION_TOOLS = new Set<SessionTool>(["opencode", "claude", "codex"]);
+
+function normalizeAgentName(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+export function herdrTool(pane: PrtlPane): SessionTool {
+  const candidates = [pane.agent?.session?.agent, pane.agent?.name, pane.agent?.session?.source?.split(":").at(-1)];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const normalized = normalizeAgentName(candidate);
+    if (normalized === "opencode") return "opencode";
+    if (normalized === "claude" || normalized === "claudecode") return "claude";
+    if (normalized === "codex" || normalized === "codexcli") return "codex";
+    if (normalized === "copilot" || normalized === "copilotcli" || normalized === "githubcopilot") return "copilotcli";
+  }
+  if (!pane.agent && pane.command) return "shell";
+  return "unknown";
+}
+
+export function herdrState(pane: PrtlPane, tool = herdrTool(pane)): SessionState {
+  if (!pane.agent) return tool === "shell" ? "shell" : "unknown";
+  switch (pane.agent.status?.toLowerCase()) {
+    case "working": return "working";
+    case "idle":
+    case "done": return "idle";
+    case "blocked": return "waiting-input";
+    default: return "unknown";
+  }
+}
+
+export function herdrSessionId(pane: PrtlPane, tool = herdrTool(pane)): string {
+  const agentSessionId = pane.agent?.sessionId ?? pane.agent?.session?.value;
+  return agentSessionId && SESSION_TOOLS.has(tool)
+    ? `${tool}:${agentSessionId}`
+    : `herdr:${pane.id}`;
+}
+
+export function herdrSummary(pane: PrtlPane): string {
+  const statusLabel = pane.agent?.status ? pane.stateLabels?.[pane.agent.status] : undefined;
+  return pane.customStatus
+    ?? statusLabel
+    ?? pane.title
+    ?? pane.terminalTitleStripped
+    ?? pane.displayAgent
+    ?? pane.command
+    ?? pane.agent?.name
+    ?? pane.tab
+    ?? pane.workspace
+    ?? "Herdr pane";
+}
+
+/**
+ * Explicit pane name only. prtl-core's `pane.name` falls back to the agent
+ * name when the pane has no label; in that case the pane is unnamed and the
+ * label logic must fall back to the tab name instead. The raw herdr record
+ * carries the original pane fields, which is the only way to distinguish an
+ * explicit name from prtl-core's agent-derived fallback.
+ */
+export function herdrPaneName(pane: PrtlPane): string | undefined {
+  const raw = (pane.metadata?.raw as { pane?: { title?: unknown; label?: unknown; name?: unknown } } | undefined)?.pane;
+  if (raw) {
+    const explicit = [raw.name, raw.title, raw.label].find(
+      (value) => typeof value === "string" && value.trim().length > 0,
+    );
+    return typeof explicit === "string" ? explicit.trim() : undefined;
+  }
+  // No raw record to discriminate: only trust an explicitly-typed PrtlPane
+  // name field (raw pane title/title/label from the provider), never render
+  // the agent-derived fallback as a pane name.
+  return pane.title?.trim() || undefined;
+}
+
+export function herdrPaneToSession(pane: PrtlPane, project?: ProjectInfo): SessionModel {
+  const tool = herdrTool(pane);
+  const state = herdrState(pane, tool);
+  const agentSessionId = pane.agent?.sessionId ?? pane.agent?.session?.value;
+  const collectedAt = Date.parse(pane.metadata.collectedAt);
+  return {
+    id: herdrSessionId(pane, tool),
+    source: "herdr",
+    tool,
+    state,
+    project,
+    summary: herdrSummary(pane),
+    lastActivity: Number.isFinite(collectedAt) ? collectedAt : Date.now(),
+    hasAttention: state === "waiting-input",
+    activeTool: pane.agent?.name,
+    detectionSource: "herdr",
+    currentCommand: pane.command,
+    currentPath: pane.foregroundCwd ?? pane.cwd,
+    paneTitle: pane.title,
+    herdr: {
+      paneId: pane.id,
+      terminalId: pane.terminalId,
+      workspaceId: pane.workspaceId,
+      workspace: pane.workspace,
+      tabId: pane.tabId,
+      tab: pane.tab,
+      name: herdrPaneName(pane),
+      focused: pane.focused,
+      providerSource: pane.metadata.source,
+      agent: pane.agent?.name,
+      agentStatus: pane.agent?.status,
+      agentSessionId,
+    },
+  };
+}

package/src/daemon/collectors/opencode/collector.ts

@@ -258,8 +258,9 @@ export class OpenCodeCollector implements Collector {
                 inst.url,
                 inst.pendingPermissions,
                 inst.pendingQuestions,
+                this.gitCollector,
               );
-              const merged: SessionModel = { ...existing, state: updated.state, hasAttention: updated.hasAttention };
+              const merged: SessionModel = { ...existing, state: updated.state, hasAttention: updated.hasAttention, project: updated.project ?? existing.project };
               inst.sessions.set(props.sessionID, merged);
               store.upsertSession(merged);
               if (prevState !== merged.state) {
@@ -385,8 +386,9 @@ export class OpenCodeCollector implements Collector {
       inst.url,
       inst.pendingPermissions,
       inst.pendingQuestions,
+      this.gitCollector,
     );
-    const merged: SessionModel = { ...existing, state: updated.state, hasAttention: updated.hasAttention };
+    const merged: SessionModel = { ...existing, state: updated.state, hasAttention: updated.hasAttention, project: updated.project ?? existing.project };
     inst.sessions.set(sessionId, merged);
     store.upsertSession(merged);
     if (prevState !== merged.state) {

package/src/daemon/collectors/opencode-db.ts

@@ -5,7 +5,7 @@
  * existing sessions in the store. Runs every 30 seconds.
  *
  * Priority rules:
- * - NEVER overwrites `state` — only metadata fields are written.
+ * - Preserves state from native collectors; a matching herdr placeholder is claimed as idle.
  * - If a session already exists (from SSE/webhook), merges title/directory/lastActivity.
  * - If a session does NOT exist yet, adds it with state="idle" and detectionSource="opencode-db".
  */
@@ -39,6 +39,16 @@ export function inferChildSessionState(
   return "working";
 }
 
+export function claimHerdrSessionForOpenCodeDb(existing: SessionModel, sessionId: string): SessionModel {
+  if (existing.detectionSource !== "herdr") return existing;
+  return {
+    ...existing,
+    state: "idle",
+    detectionSource: "opencode-db",
+    opencode: existing.opencode ?? { sessionId, instanceUrl: "" },
+  };
+}
+
 // ── DB path resolution ────────────────────────────────────────────────────────
 
 /**
@@ -202,6 +212,8 @@ export class OpenCodeDbCollector implements Collector {
         const existing = store.getSession(storeId);
 
         if (existing) {
+          const replacingHerdr = existing.detectionSource === "herdr";
+          const owned = claimHerdrSessionForOpenCodeDb(existing, row.id);
           // Merge-only: preserve state, just update metadata
           const newParentSessionId = row.parent_id ? `opencode:${row.parent_id}` : undefined;
           const effectiveParentSessionId = newParentSessionId ?? existing.parentSessionId;
@@ -211,19 +223,19 @@ export class OpenCodeDbCollector implements Collector {
             existing.lastActivity !== row.time_updated ||
             existing.parentSessionId !== newParentSessionId;
           const targetState = inferChildSessionState(
-            existing,
+            owned,
             effectiveParentSessionId ? store.getSession(effectiveParentSessionId) : undefined,
             config,
             now,
           );
 
-          if (needsUpdate || (targetState !== undefined && targetState !== existing.state)) {
+          if (replacingHerdr || needsUpdate || (targetState !== undefined && targetState !== existing.state)) {
             const project = row.directory
               ? (this.gitCollector?.resolve(row.directory) ?? existing.project)
               : existing.project;
             const merged: SessionModel = {
-              ...existing,
-              state: targetState ?? existing.state,
+              ...owned,
+              state: targetState ?? owned.state,
               summary: row.title || existing.summary,
               currentPath: row.directory ?? existing.currentPath,
               lastActivity: Math.max(existing.lastActivity, row.time_updated),

package/src/daemon/collectors/tmux/collector.ts

@@ -169,6 +169,7 @@ export class TmuxCollector implements Collector {
             tmux: {
               session: pane.sessionName,
               window: String(pane.windowIndex),
+              windowName: pane.windowName,
               pane: pane.paneId,
             },
             legacyPaneId: pane.paneId,
@@ -230,6 +231,7 @@ export class TmuxCollector implements Collector {
             tmux: {
               session: pane.sessionName,
               window: String(pane.windowIndex),
+              windowName: pane.windowName,
               pane: pane.paneId,
             },
             legacyPaneId: pane.paneId,
@@ -295,6 +297,7 @@ export class TmuxCollector implements Collector {
             tmux: {
               session: pane.sessionName,
               window: String(pane.windowIndex),
+              windowName: pane.windowName,
               pane: pane.paneId,
             },
             legacyPaneId: pane.paneId,
@@ -365,6 +368,7 @@ export class TmuxCollector implements Collector {
             tmux: {
               session: pane.sessionName,
               window: String(pane.windowIndex),
+              windowName: pane.windowName,
               pane: pane.paneId,
             },
             legacyPaneId: pane.paneId,
@@ -416,6 +420,7 @@ export class TmuxCollector implements Collector {
                 tmux: {
                   session: pane.sessionName,
                   window: String(pane.windowIndex),
+                  windowName: pane.windowName,
                   pane: pane.paneId,
                 },
                 legacyPaneId: pane.paneId,
@@ -467,6 +472,21 @@ export class TmuxCollector implements Collector {
       (s) => !(s.source === "tmux" && s.detectionSource === "fallback-detection"),
     );
 
-    store.setSessions([...nonFallback, ...newFallbackSessions]);
+    // Fallback sessions are rebuilt from scratch every poll. Git project
+    // resolution can transiently fail (or currentPath can come through empty),
+    // so inherit the previously-resolved project/currentPath to keep the TUI
+    // group membership stable instead of oscillating between polls.
+    const previousFallback = new Map(
+      current
+        .filter((s) => s.source === "tmux" && s.detectionSource === "fallback-detection")
+        .map((s) => [s.id, s]),
+    );
+    const mergedFallbacks = newFallbackSessions.map((session) => {
+      const prev = previousFallback.get(session.id);
+      if (!prev || session.project) return session;
+      return { ...session, project: prev.project, currentPath: session.currentPath || prev.currentPath };
+    });
+
+    store.setSessions([...nonFallback, ...mergedFallbacks]);
   }
 }

package/src/daemon/collectors/tmux/enrichment.ts

@@ -218,6 +218,7 @@ export function paneModelToSession(pane: ReturnType<typeof classifyPane>["pane"]
     tmux: {
       session: pane.sessionName,
       window: String(pane.windowIndex),
+      windowName: pane.windowName,
       pane: pane.paneId,
     },
     summary: codexPrompt?.summary ?? claudePrompt?.summary ?? pane.summary,

package/src/daemon/collectors/usage.ts

@@ -10,9 +10,16 @@ import { ClaudeWebResolver } from "../../usage/resolvers/claude-web";
 import { ClaudeCliResolver } from "../../usage/resolvers/claude-cli";
 import { CodexAuthResolver } from "../../usage/resolvers/codex-auth";
 import { OpenCodeGoWebResolver } from "../../usage/resolvers/opencode-go-web";
+import { keychainCoordinator } from "../../usage/resolvers/keychain-coordinator";
 import type { DaemonStore } from "../store";
 import type { Collector } from "../scheduler";
 
+interface UsageResolverSet {
+  claudeProvider: ClaudeUsageProvider;
+  codexProvider: CodexUsageProvider;
+  opencodeGoProvider: OpenCodeGoUsageProvider;
+}
+
 export class UsageCollector implements Collector {
   name = "usage";
   private timer?: ReturnType<typeof setInterval>;
@@ -22,11 +29,24 @@ export class UsageCollector implements Collector {
   private polling = false;
   private skippedPolls = 0;
   private errorCount = 0;
+  private pollController?: AbortController;
+  private resolverSet?: UsageResolverSet;
 
   async start(store: DaemonStore, config: ScrylogConfig, logger: Logger): Promise<void> {
     this.store = store;
     this.config = config;
     this.logger = logger;
+    keychainCoordinator.configure({
+      allowPrompts: () => config.usage.auth.allowKeychainPrompts,
+      onFailure: (failure) =>
+        logger.warn("usage", "Keychain read failed", {
+          event: "keychain_read_failed",
+          code: failure.code,
+          service: failure.service,
+          account: failure.account ?? null,
+          cooldownUntil: failure.cooldownUntil ? new Date(failure.cooldownUntil).toISOString() : null,
+        }),
+    });
 
     logger.info("usage", "Collector started", { event: "collector.started", collector: this.name, intervalMs: config.usage.pollIntervalMs, providers: config.usage.providers });
 
@@ -40,6 +60,10 @@ export class UsageCollector implements Collector {
       clearInterval(this.timer);
       this.timer = undefined;
     }
+    this.pollController?.abort();
+    // Drop resolver/provider instances so a later start() rebuilds them from
+    // the current configuration instead of reusing stale constructor args.
+    this.resolverSet = undefined;
     this.logger?.info("usage", "Collector stopped", { event: "collector.stopped", collector: this.name });
   }
 
@@ -53,49 +77,43 @@ export class UsageCollector implements Collector {
     }
 
     this.polling = true;
+    const pollController = new AbortController();
+    this.pollController = pollController;
     const startedAt = Date.now();
     try {
-      await this.poll();
+      await this.poll(pollController.signal);
       store.setCollectorStatus(this.name, { lastDurationMs: Date.now() - startedAt, skippedPolls: this.skippedPolls, errorCount: this.errorCount });
+    } catch (error) {
+      if (!pollController.signal.aborted) {
+        this.errorCount += 1;
+        this.logger?.warn("usage", "Poll failed", {
+          event: "collector.poll_failed",
+          collector: this.name,
+          errorMessage: error instanceof Error ? error.message : String(error),
+        });
+      }
     } finally {
+      if (this.pollController === pollController) this.pollController = undefined;
       this.polling = false;
     }
   }
 
-  private async poll(): Promise<void> {
+  private async poll(signal: AbortSignal): Promise<void> {
     const store = this.store!;
     const config = this.config!;
     const logger = this.logger!;
 
+    const resolvers = this.ensureResolvers(config);
     const providers: UsageProviderEntry[] = [];
     const attemptedAt = Date.now();
 
     for (const providerName of config.usage.providers) {
       if (providerName === "claude") {
-        const oauthResolver = new ClaudeAuthResolver();
-        const webResolver = new ClaudeWebResolver();
-        const cliResolver = new ClaudeCliResolver();
-        const planner = new ClaudeSourcePlanner(
-          {
-            dataSource: config.usage.claude.dataSource,
-            webExtrasEnabled: config.usage.claude.webExtrasEnabled,
-          },
-          oauthResolver,
-          webResolver,
-          cliResolver,
-        );
-
-        const decision = await planner.decide();
-        if (decision.primary === "auto") {
-          logger.debug("usage", "Claude not available on this machine, omitting from response", { event: "provider.unavailable", provider: "claude" });
-          continue;
-        }
-
-        const claudeProvider = new ClaudeUsageProvider(planner, oauthResolver, webResolver, cliResolver);
         try {
-          const result = await withAbort((signal) => claudeProvider.fetch({ signal }), config.daemon.networkTimeoutMs, "Claude usage fetch timed out");
+          const result = await withAbort((requestSignal) => resolvers.claudeProvider.fetch({ signal: requestSignal }), config.daemon.networkTimeoutMs, "Claude usage fetch timed out", signal);
           providers.push(result.entry);
         } catch (err) {
+          if (signal.aborted) throw err;
           this.errorCount += 1;
           const message = err instanceof Error ? err.message : String(err);
           logger.warn("usage", "Claude provider unexpected error", { event: "provider.fetch_failed", provider: "claude", errorMessage: message });
@@ -108,19 +126,11 @@ export class UsageCollector implements Collector {
           });
         }
       } else if (providerName === "codex") {
-        const resolver = new CodexAuthResolver();
-
-        if (!(await resolver.isAvailable())) {
-          logger.debug("usage", "Codex not available on this machine, omitting from response", { event: "provider.unavailable", provider: "codex" });
-          continue;
-        }
-
-        const provider = new CodexUsageProvider(resolver);
-
         try {
-          const result = await withAbort((signal) => provider.fetch({ signal }), config.daemon.networkTimeoutMs, "Codex usage fetch timed out");
+          const result = await withAbort((requestSignal) => resolvers.codexProvider.fetch({ signal: requestSignal }), config.daemon.networkTimeoutMs, "Codex usage fetch timed out", signal);
           providers.push(result.entry);
         } catch (err) {
+          if (signal.aborted) throw err;
           this.errorCount += 1;
           const message = err instanceof Error ? err.message : String(err);
           logger.warn("usage", "Codex provider unexpected error", { event: "provider.fetch_failed", provider: "codex", errorMessage: message });
@@ -133,19 +143,11 @@ export class UsageCollector implements Collector {
           });
         }
       } else if (providerName === "opencode-go") {
-        const resolver = new OpenCodeGoWebResolver();
-
-        if (!(await resolver.isAvailable())) {
-          logger.debug("usage", "OpenCode Go not available on this machine, omitting from response", { event: "provider.unavailable", provider: "opencode-go" });
-          continue;
-        }
-
-        const provider = new OpenCodeGoUsageProvider(resolver, config.usage.opencodeGo.serverFnId);
-
         try {
-          const result = await withAbort((signal) => provider.fetch({ signal }), config.daemon.networkTimeoutMs, "OpenCode Go usage fetch timed out");
+          const result = await withAbort((requestSignal) => resolvers.opencodeGoProvider.fetch({ signal: requestSignal }), config.daemon.networkTimeoutMs, "OpenCode Go usage fetch timed out", signal);
           providers.push(result.entry);
         } catch (err) {
+          if (signal.aborted) throw err;
           this.errorCount += 1;
           const message = err instanceof Error ? err.message : String(err);
           logger.warn("usage", "OpenCode Go provider unexpected error", { event: "provider.fetch_failed", provider: "opencode-go", errorMessage: message });
@@ -169,23 +171,87 @@ export class UsageCollector implements Collector {
     store.setCollectorStatus(this.name, { running: true, lastRunAt: attemptedAt, skippedPolls: this.skippedPolls, errorCount: this.errorCount });
     logger.debug("usage", "Poll complete", { event: "collector.poll_completed", collector: this.name, providerCount: providers.length });
   }
+
+  /**
+   * Resolvers and providers are created once per collector lifetime so
+   * resolved credentials stay cached across polls instead of re-reading
+   * credential sources on every cycle.
+   */
+  private ensureResolvers(config: ScrylogConfig): UsageResolverSet {
+    if (!this.resolverSet) {
+      const oauthResolver = new ClaudeAuthResolver();
+      const webResolver = new ClaudeWebResolver();
+      const cliResolver = new ClaudeCliResolver();
+      const planner = new ClaudeSourcePlanner(
+        {
+          dataSource: config.usage.claude.dataSource,
+          webExtrasEnabled: config.usage.claude.webExtrasEnabled,
+        },
+        oauthResolver,
+        webResolver,
+        cliResolver,
+      );
+
+      this.resolverSet = {
+        claudeProvider: new ClaudeUsageProvider(planner, oauthResolver, webResolver, cliResolver),
+        codexProvider: new CodexUsageProvider(
+          new CodexAuthResolver(config.usage.codex.chatgptBaseUrl),
+          config.usage.codex.dataSource,
+        ),
+        opencodeGoProvider: new OpenCodeGoUsageProvider(
+          new OpenCodeGoWebResolver(),
+          config.usage.opencodeGo.serverFnId,
+        ),
+      };
+    }
+    return this.resolverSet;
+  }
 }
 
-function withAbort<T>(run: (signal: AbortSignal) => Promise<T>, timeoutMs: number, message: string): Promise<T> {
+export function withAbort<T>(
+  run: (signal: AbortSignal) => Promise<T>,
+  timeoutMs: number,
+  message: string,
+  parentSignal?: AbortSignal,
+): Promise<T> {
   const controller = new AbortController();
-  const promise = run(controller.signal);
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
+  if (parentSignal?.aborted) {
+    controller.abort();
+    return Promise.reject(new Error("Usage poll cancelled"));
+  }
+  return new Promise<T>((resolve, reject) => {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      parentSignal?.removeEventListener("abort", onParentAbort);
+    };
+    const onParentAbort = () => {
+      controller.abort();
+      reject(new Error("Usage poll cancelled"));
+    };
+    parentSignal?.addEventListener("abort", onParentAbort, { once: true });
+    // Register the deadline before starting the request so the first
+    // synchronous step is already bounded.
+    timer = setTimeout(() => {
       controller.abort();
       reject(new Error(message));
     }, timeoutMs);
+
+    let promise: Promise<T>;
+    try {
+      promise = run(controller.signal);
+    } catch (error) {
+      cleanup();
+      reject(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
     promise.then(
       (value) => {
-        clearTimeout(timer);
+        cleanup();
         resolve(value);
       },
       (error) => {
-        clearTimeout(timer);
+        cleanup();
         reject(error);
       },
     );

package/src/daemon/index.ts

@@ -6,6 +6,7 @@ import { IS_WINDOWS } from "../shared/platform";
 import { DaemonStore } from "./store";
 import { Scheduler } from "./scheduler";
 import { TmuxCollector } from "./collectors/tmux";
+import { HerdrCollector } from "./collectors/herdr";
 import { ProcessCollector } from "./collectors/process";
 import { GitCollector } from "./collectors/git";
 import { OpenCodeCollector } from "./collectors/opencode";
@@ -78,6 +79,7 @@ const gitCollector = new GitCollector();
 scheduler.register(processCollector);
 scheduler.register(gitCollector);
 scheduler.register(new TmuxCollector(processCollector, gitCollector));
+scheduler.register(new HerdrCollector(gitCollector));
 if (config.opencode.mode === "sse") {
   scheduler.register(new OpenCodeCollector(gitCollector));
 }