@scrylog/cli 0.2.0 → 0.3.0

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));
 }

package/src/daemon/store.ts

@@ -124,6 +124,24 @@ export class DaemonStore extends EventEmitter {
     // enrichment fields. This prevents the opencode SDK/DB/cluade collectors from
     // wiping out tmux enrichment on every poll/SSE cycle.
     let session = incoming;
+    if (
+      existing?.source === "herdr"
+      && existing.herdr
+      && incoming.detectionSource !== "herdr"
+      && incoming.source !== "tmux"
+      && !incoming.tmux
+      && !incoming.legacyPaneId
+    ) {
+      session = {
+        ...incoming,
+        source: "herdr",
+        herdr: existing.herdr,
+        project: incoming.project ?? existing.project,
+        currentPath: incoming.currentPath ?? existing.currentPath,
+        currentCommand: incoming.currentCommand ?? existing.currentCommand,
+        paneTitle: incoming.paneTitle ?? existing.paneTitle,
+      };
+    }
     if (existing?.legacyPaneId && !incoming.legacyPaneId) {
       const stableForMs = existing.state !== incoming.state ? 0 : existing.stableForMs;
       session = {
@@ -419,6 +437,29 @@ export class DaemonStore extends EventEmitter {
     };
   }
 
+  /** Remove herdr location while retaining native collector session data. */
+  clearHerdrBinding(sessionId: string): void {
+    const existing = this.state.sessions.find((session) => session.id === sessionId);
+    if (!existing || existing.source !== "herdr" || !existing.herdr || existing.detectionSource === "herdr") {
+      return;
+    }
+
+    const session: SessionModel = {
+      ...existing,
+      source: "standalone",
+      herdr: undefined,
+      currentCommand: undefined,
+      paneTitle: undefined,
+    };
+    this.state = {
+      ...this.state,
+      sessions: this.state.sessions.map((item) => item.id === sessionId ? session : item),
+      refreshedAt: Date.now(),
+    };
+    this.emit("store:event", { type: "session:updated", session } satisfies StoreEvent);
+    this.emit("store:event", { type: "state:refreshed", timestamp: this.state.refreshedAt } satisfies StoreEvent);
+  }
+
   /** Update usage state and emit event */
   setUsage(usage: import("../usage/types").UsageState): void {
     this.state = { ...this.state, usage };
@@ -518,9 +559,10 @@ export class DaemonStore extends EventEmitter {
     const maxSessions = retention.maxSessions;
     if (maxSessions > 0) {
       const survivors = this.state.sessions.filter((session) => !removeIds.has(session.id));
-      const overflow = survivors.length - maxSessions;
+      const counted = survivors.filter((session) => session.source === "standalone" && session.tool !== "unknown");
+      const overflow = counted.length - maxSessions;
       if (overflow > 0) {
-        const candidates = survivors
+        const candidates = counted
           .filter((session) => !active(session))
           .sort((a, b) => a.lastActivity - b.lastActivity);
         for (const session of candidates.slice(0, overflow)) {

package/src/postinstall.cjs

@@ -0,0 +1,11 @@
+const message = [
+  "scrylog installed or updated.",
+  "If scrylogd is already running, activate this version with:",
+  "  scrylog daemon restart",
+  "For a foreground or unsupported service, stop it and run:",
+  "  scrylogd",
+  "Hooks use the installed binaries and do not need reinstallation.",
+  "If integrations misbehave, run: scrylog setup",
+].join("\n");
+
+process.stdout.write(`${message}\n`);

package/src/shared/config.ts

@@ -91,8 +91,20 @@ export interface TuiConfig {
   standaloneMaxAgeHours: number;
   /** Debounce window in ms for coalescing push-event bursts into a single refresh (default: 120, 0 = disabled) */
   pushDebounceMs: number;
+  /**
+   * Provider icon rendering mode (default: blocks):
+   * - "blocks": terminal pixel art, works everywhere including tmux
+   * - "graphics": full artwork negotiated automatically (kitty → sixel → blocks)
+   * - "kitty" / "sixel": force a specific native graphics protocol, ignoring detection
+   * - "text": colored provider initials
+   */
+  providerIcons: "blocks" | "graphics" | "kitty" | "sixel" | "text";
 }
 
+type ProviderIconsMode = TuiConfig["providerIcons"];
+
+const PROVIDER_ICON_MODES: readonly ProviderIconsMode[] = ["blocks", "graphics", "kitty", "sixel", "text"];
+
 export interface McpConfig {
   /** Whether the local stdio MCP binary should be allowed (default: true) */
   stdioEnabled: boolean;
@@ -142,6 +154,14 @@ export interface UsageOpenCodeGoConfig {
   serverFnId: string;
 }
 
+export interface UsageAuthConfig {
+  /**
+   * Whether background usage polls may read foreign Keychain secrets (macOS).
+   * `false` keeps the daemon prompt-free but disables Keychain-backed credential sources.
+   */
+  allowKeychainPrompts: boolean;
+}
+
 export interface UsageConfig {
   /** Whether usage collection is enabled (default: true) */
   enabled: boolean;
@@ -152,6 +172,7 @@ export interface UsageConfig {
   claude: UsageClaudeConfig;
   codex: UsageCodexConfig;
   opencodeGo: UsageOpenCodeGoConfig;
+  auth: UsageAuthConfig;
 }
 
 export interface RetentionConfig {
@@ -233,6 +254,7 @@ export const CONFIG_DEFAULTS: ScrylogConfig = {
     usePushUpdates: true,
     standaloneMaxAgeHours: 6,
     pushDebounceMs: 120,
+    providerIcons: "blocks",
   },
   mcp: {
     stdioEnabled: true,
@@ -254,6 +276,9 @@ export const CONFIG_DEFAULTS: ScrylogConfig = {
     opencodeGo: {
       serverFnId: "def39973159c7f0483d8793a822b8dbb10d067e12c65455fcb4608459ba0234f",
     },
+    auth: {
+      allowKeychainPrompts: true,
+    },
   },
   retention: {
     maxSessions: 500,
@@ -456,10 +481,18 @@ function normalizeOperationalConfig(config: ScrylogConfig): ScrylogConfig {
       refreshMs: clampNumber(config.tui.refreshMs, 500, 300_000, CONFIG_DEFAULTS.tui.refreshMs),
       standaloneMaxAgeHours: clampNumber(config.tui.standaloneMaxAgeHours, 0, 8_760, CONFIG_DEFAULTS.tui.standaloneMaxAgeHours),
       pushDebounceMs: clampNumber(config.tui.pushDebounceMs, 0, 2_000, CONFIG_DEFAULTS.tui.pushDebounceMs),
+      providerIcons: PROVIDER_ICON_MODES.includes(config.tui.providerIcons)
+        ? config.tui.providerIcons
+        : CONFIG_DEFAULTS.tui.providerIcons,
     },
     usage: {
       ...config.usage,
       pollIntervalMs: clampNumber(config.usage.pollIntervalMs, 60_000, 3_600_000, CONFIG_DEFAULTS.usage.pollIntervalMs),
+      auth: {
+        allowKeychainPrompts: typeof config.usage.auth?.allowKeychainPrompts === "boolean"
+          ? config.usage.auth.allowKeychainPrompts
+          : CONFIG_DEFAULTS.usage.auth.allowKeychainPrompts,
+      },
     },
     retention: {
       ...config.retention,

package/src/shared/session-exclusions.ts

@@ -0,0 +1,5 @@
+const CLAUDE_PROBE_PATH = /(?:^|[\\/-])codexbar[\\/-]claudeprobe(?:$|[\\/-])/i;
+
+export function isKnownClaudeProbePath(path?: string): boolean {
+  return typeof path === "string" && CLAUDE_PROBE_PATH.test(path);
+}

package/src/shared/session-view.ts

@@ -15,6 +15,18 @@ export interface SessionListTmuxInfo {
   session: string;
   window: string;
   pane: string;
+  windowName?: string;
+}
+
+export interface SessionListHerdrInfo {
+  paneId: string;
+  terminalId?: string;
+  workspaceId?: string;
+  workspace?: string;
+  tabId?: string;
+  tab?: string;
+  name?: string;
+  agent?: string;
 }
 
 export interface SessionListItem {
@@ -28,8 +40,11 @@ export interface SessionListItem {
   hasAttention?: boolean;
   detectionSource?: SessionModel["detectionSource"];
   parentSessionId?: string;
+  /** Human label for the session row: pane title > window/tab name > tmux session name */
+  displayName?: string;
   project?: SessionListProjectInfo;
   tmux?: SessionListTmuxInfo;
+  herdr?: SessionListHerdrInfo;
   currentPath?: string;
   activeTool?: string;
   childCount?: number;
@@ -54,6 +69,10 @@ export interface SessionView {
   sessions: SessionTreeItem[];
 }
 
+export interface SessionViewOptions {
+  includeUnknown?: boolean;
+}
+
 function makeStateCounts(): Record<SessionState, number> {
   return {
     working: 0,
@@ -90,7 +109,16 @@ function isEphemeralCodexRootSession(session: SessionModel, now: number): boolea
     && now - session.lastActivity > CODEX_ROOT_EPHEMERAL_GRACE_MS;
 }
 
-function isCanonicallyVisible(session: SessionModel, config: ScrylogConfig, now: number): boolean {
+function isCanonicallyVisible(
+  session: SessionModel,
+  config: ScrylogConfig,
+  now: number,
+  options: SessionViewOptions,
+): boolean {
+  if (session.tool === "unknown" && !options.includeUnknown) {
+    return false;
+  }
+
   if (session.parentSessionId) {
     return session.state === "working" || session.state === "waiting-input";
   }
@@ -125,6 +153,23 @@ function toProject(project?: ProjectInfo): SessionListProjectInfo | undefined {
 
 const GRACE_PERIOD_MS = 1500;
 
+function resolveDisplayName(session: SessionModel): string | undefined {
+  if (session.tmux) {
+    return session.paneTitle?.trim()
+      || session.tmux.windowName?.trim()
+      || session.tmux.session?.trim()
+      || undefined;
+  }
+  if (session.herdr) {
+    return session.herdr.name?.trim()
+      || session.herdr.tab?.trim()
+      || session.herdr.agent?.trim()
+      || session.herdr.paneId
+      || undefined;
+  }
+  return undefined;
+}
+
 function effectiveState(session: SessionModel, activeChildCount: number, now: number): SessionState {
   if (session.state === "idle" && !session.parentSessionId) {
     if (activeChildCount > 0) {
@@ -160,8 +205,19 @@ function toListItem(session: SessionModel, childCount: number, activeChildCount:
     hasAttention: session.hasAttention,
     detectionSource: session.detectionSource,
     parentSessionId: session.parentSessionId,
+    displayName: resolveDisplayName(session),
     project: toProject(session.project),
-    tmux: session.tmux,
+    tmux: session.tmux ? { ...session.tmux } : undefined,
+    herdr: session.herdr ? {
+      paneId: session.herdr.paneId,
+      terminalId: session.herdr.terminalId,
+      workspaceId: session.herdr.workspaceId,
+      workspace: session.herdr.workspace,
+      tabId: session.herdr.tabId,
+      tab: session.herdr.tab,
+      name: session.herdr.name,
+      agent: session.herdr.agent,
+    } : undefined,
     currentPath: session.currentPath,
     activeTool: session.activeTool,
     childCount,
@@ -179,7 +235,12 @@ export function flattenSessionTree(sessions: SessionTreeItem[]): SessionListItem
   return flat;
 }
 
-export function buildSessionView(sessions: SessionModel[], config: ScrylogConfig, now = Date.now()): SessionView {
+export function buildSessionView(
+  sessions: SessionModel[],
+  config: ScrylogConfig,
+  now = Date.now(),
+  options: SessionViewOptions = {},
+): SessionView {
   const byId = new Map(sessions.map((session) => [session.id, session]));
   const allChildren = new Map<string, SessionModel[]>();
   const visibleChildren = new Map<string, SessionModel[]>();
@@ -191,20 +252,20 @@ export function buildSessionView(sessions: SessionModel[], config: ScrylogConfig
       arr.push(session);
       allChildren.set(session.parentSessionId, arr);
 
-      if (isCanonicallyVisible(session, config, now)) {
+      if (isCanonicallyVisible(session, config, now, options)) {
         const visibleArr = visibleChildren.get(session.parentSessionId) ?? [];
         visibleArr.push(session);
         visibleChildren.set(session.parentSessionId, visibleArr);
 
         const parent = byId.get(session.parentSessionId);
-        if (parent) {
+        if (parent && isCanonicallyVisible(parent, config, now, options)) {
           visibleRoots.set(parent.id, parent);
         }
       }
       continue;
     }
 
-    if (isCanonicallyVisible(session, config, now)) {
+    if (isCanonicallyVisible(session, config, now, options)) {
       visibleRoots.set(session.id, session);
     }
   }