@scrylog/cli 0.1.4 → 0.3.0

package/src/cli/commands.ts

@@ -9,12 +9,27 @@ import { getDaemonLogPath } from "../shared/paths";
 import { createPromptSession } from "./prompt";
 import { getServiceManagerOrThrow } from "../service/manager";
 import { createDaemonFetch, getSocketPath } from "../shared/ipc";
-import { IS_WINDOWS, whichCommand } from "../shared/platform";
+import { adviseProviderIcons, probeTerminalGraphics } from "../shared/terminal-capabilities";
+import { IS_MAC, IS_WINDOWS, whichCommand } from "../shared/platform";
+import { formatVersionDiagnostics, getInstalledVersion } from "../shared/version";
+import { listSessions } from "@joeldmtz/prtl-core";
+import type { ListSessionsOptions, PrtlListResult } from "@joeldmtz/prtl-core";
 
 export interface GlobalCliOptions {
   configPath?: string;
 }
 
+type HerdrList = (options?: ListSessionsOptions) => Promise<PrtlListResult>;
+
+export async function isHerdrAvailable(timeoutMs: number, list: HerdrList = listSessions): Promise<boolean> {
+  try {
+    const result = await list({ provider: "herdr", timeoutMs });
+    return result.metadata.providers.herdr?.available === true;
+  } catch {
+    return false;
+  }
+}
+
 export async function runDaemonCommand(action: string, options: GlobalCliOptions): Promise<void> {
   const manager = getServiceManagerOrThrow();
   if (action === "install") {
@@ -89,7 +104,7 @@ export function runTokenCommand(target: "mcp" | "api" | "both", action: string,
   throw new Error(`Unknown token action: ${action}`);
 }
 
-export async function runLogsCommand(): Promise<void> {
+export async function runLogsCommand(_options: GlobalCliOptions): Promise<void> {
   const logPath = getDaemonLogPath();
   process.stdout.write(`Log path: ${logPath}\n`);
   if (!existsSync(logPath)) {
@@ -102,8 +117,32 @@ export async function runLogsCommand(): Promise<void> {
   process.stdout.write(`${recent.join("\n")}\n`);
 }
 
-export async function runDoctor(options: GlobalCliOptions): Promise<void> {
-  const configPath = getResolvedConfigPath(options.configPath);
+interface ClaudeCredentialDiagnostics {
+  state: "missing" | "expired" | "valid";
+}
+
+/**
+ * Claude credential state for doctor diagnostics, derived from the running
+ * daemon's usage state. Reports only the state — never prints token material.
+ * Returns null when the daemon is unreachable (no line is printed).
+ */
+async function claudeCredentialState(daemonFetch: Awaited<ReturnType<typeof createDaemonFetch>>): Promise<ClaudeCredentialDiagnostics | null> {
+  try {
+    const usage = await daemonFetch("/api/usage") as { providers?: Array<{ provider: string; status: string; errors?: string[] }> };
+    const claude = usage.providers?.find((provider) => provider.provider === "claude");
+    if (!claude) return null;
+    if (claude.status === "ok") return { state: "valid" };
+    if (claude.status === "unavailable") {
+      const expired = (claude.errors ?? []).some((message) => message.includes("expired") || message.includes("re-login"));
+      return { state: expired ? "expired" : "missing" };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function runDoctor(options: GlobalCliOptions): Promise<void> {  const configPath = getResolvedConfigPath(options.configPath);
   const config = loadConfig(options.configPath);
   const daemonFetch = createDaemonFetch({
     host: config.api.host,
@@ -121,12 +160,33 @@ export async function runDoctor(options: GlobalCliOptions): Promise<void> {
   process.stdout.write(`Retention max sessions: ${config.retention.maxSessions}\n`);
   process.stdout.write(`Retention standalone max age hours: ${config.retention.standaloneMaxAgeHours}\n`);
   process.stdout.write(`Usage enabled: ${config.usage.enabled}\n`);
+  if (IS_MAC && config.usage.enabled) {
+    process.stdout.write(`Keychain prompts allowed: ${config.usage.auth.allowKeychainPrompts}\n`);
+    process.stdout.write("Keychain items the daemon may read: claude-api-oauth, Claude Code-credentials, Claude Safe Storage, per-browser Safe Storage (Chrome, Brave, Edge, Arc, Vivaldi, Chromium)\n");
+    process.stdout.write("Keychain note: macOS authorization is granted per item — you have about 90 seconds to answer each dialog; click \"Always Allow\" once per item. Successful reads are memoized for the daemon's lifetime, so each item prompts at most once per daemon run, and an unanswered dialog retries after 10 minutes. Set usage.auth.allowKeychainPrompts to false to suppress all keychain prompts.\n");
+
+    const claudeCredential = await claudeCredentialState(daemonFetch);
+    if (claudeCredential?.state === "valid") {
+      process.stdout.write("Claude credential: valid (OAuth session active)\n");
+    } else if (claudeCredential?.state === "expired") {
+      process.stdout.write("Claude credential: expired — run \"claude\" and log in to refresh, then restart the daemon\n");
+    } else if (claudeCredential?.state === "missing") {
+      process.stdout.write("Claude credential: not found — run \"claude\" and log in to enable the Claude OAuth usage source\n");
+    }
+  }
 
   try {
     const health = await daemonFetch("/api/health");
     process.stdout.write(`Local daemon reachable: ${health.ok}\n`);
+    if (health.ok) {
+      const body = await health.json().catch(() => ({})) as { version?: string };
+      process.stdout.write(formatVersionDiagnostics(getInstalledVersion(), body.version));
+    } else {
+      process.stdout.write(`CLI version: ${getInstalledVersion()}\n`);
+    }
   } catch {
     process.stdout.write("Local daemon reachable: false\n");
+    process.stdout.write(`CLI version: ${getInstalledVersion()}\n`);
   }
 
   process.stdout.write(`TCP API enabled: ${config.api.tcpEnabled}\n`);
@@ -155,6 +215,27 @@ export async function runDoctor(options: GlobalCliOptions): Promise<void> {
     process.stdout.write(`CORS origins: ${config.cors.origins.join(", ")}\n`);
   }
 
+  const graphics = await probeTerminalGraphics();
+  const advice = adviseProviderIcons(graphics);
+  process.stdout.write("\nTerminal graphics:\n");
+  if (graphics.probeFailed) {
+    const reason = graphics.probeFailedReason === "raw-unavailable"
+      ? "raw mode is unavailable in this stdin (try the interactive scrylog binary)"
+      : graphics.probeFailedReason === "no-answer"
+      ? "the terminal did not answer any probe (graphics detection is unknown)"
+      : "stdin is not an interactive TTY — attach one to test";
+    process.stdout.write(`  Probe: unavailable (${reason})\n`);
+  } else {
+    process.stdout.write(`  Terminal: ${graphics.terminalName ?? "(no XTVERSION response)"}\n`);
+    process.stdout.write(`  TERM: ${graphics.term ?? "(unset)"}\n`);
+    process.stdout.write(`  Multiplexer: ${graphics.multiplexer}\n`);
+    process.stdout.write(`  Kitty graphics: ${graphics.kittyGraphics}\n`);
+    process.stdout.write(`  Sixel: ${graphics.sixel}\n`);
+    process.stdout.write(`  Window pixel resolution: ${graphics.pixelResolution ? `${graphics.pixelResolution.width}x${graphics.pixelResolution.height}` : "(not reported)"}\n`);
+  }
+  process.stdout.write(`  providerIcons config: ${config.tui.providerIcons}\n`);
+  process.stdout.write(`  Recommended providerIcons: ${graphics.probeFailed ? `run again from an interactive terminal (${advice} is the safe default)` : advice}\n`);
+
   process.stdout.write(`MCP HTTP enabled: ${config.mcp.httpEnabled}\n`);
   if (config.mcp.httpEnabled) {
     try {
@@ -184,6 +265,7 @@ export async function runDoctor(options: GlobalCliOptions): Promise<void> {
 
   const tmux = Bun.spawnSync(["tmux", "-V"], { stdout: "pipe", stderr: "pipe" });
   process.stdout.write(`tmux available: ${tmux.exitCode === 0}\n`);
+  process.stdout.write(`herdr available: ${await isHerdrAvailable(config.daemon.commandTimeoutMs)}\n`);
 
   if (config.opencode.mode === "hooks") {
     process.stdout.write("OpenCode mode: hooks\n");
@@ -247,6 +329,24 @@ export async function runSetupWizard(options: GlobalCliOptions): Promise<void> {
       }
     }
 
+    if (isClaudeHooksInstalled()) {
+      process.stdout.write("Claude hooks already installed.\n");
+    } else {
+      const installClaude = await prompt.yesNo("Install Claude hooks now?", false);
+      if (installClaude) {
+        await runClaudeHooksInstall(options);
+      }
+    }
+
+    if (isCodexHooksInstalled()) {
+      process.stdout.write("Codex hooks already installed.\n");
+    } else {
+      const installCodex = await prompt.yesNo("Install Codex hooks now?", false);
+      if (installCodex) {
+        await runCodexHooksInstall(options);
+      }
+    }
+
     const pollInterval = await prompt.text("Daemon poll interval (ms)", String(current.daemon.pollIntervalMs));
     const logLevel = await prompt.choose("Daemon log level", ["debug", "info", "warn", "error"], ["debug", "info", "warn", "error"].indexOf(current.daemon.logLevel));
     next.daemon.pollIntervalMs = parseOptionalInt(pollInterval, current.daemon.pollIntervalMs);
@@ -326,6 +426,52 @@ function parseOptionalInt(value: string, fallback: number): number {
 
 const OPENCODE_PLUGIN_NAME = "@scrylog/opencode-plugin";
 
+export function isClaudeHooksInstalled(homeDir = homedir()): boolean {
+  const settingsPath = join(homeDir, ".claude", "settings.json");
+  if (!existsSync(settingsPath)) return false;
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as ClaudeSettings;
+    const hooks = settings.hooks ?? {};
+    return Object.values(hooks).some((rules) =>
+      rules.some((rule) =>
+        rule.hooks.some((h) => typeof h.command === "string" && h.command.includes("scrylog-claude-hook")),
+      ),
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function isCodexHooksInstalled(homeDir = homedir()): boolean {
+  const codexDir = process.env.CODEX_HOME ? process.env.CODEX_HOME : join(homeDir, ".codex");
+  const hooksPath = join(codexDir, "hooks.json");
+  if (!existsSync(hooksPath)) return false;
+  try {
+    const config = JSON.parse(readFileSync(hooksPath, "utf8")) as CodexHooksConfig;
+    const hooks = config.hooks ?? {};
+    return Object.values(hooks).some((rules) =>
+      rules.some((rule) =>
+        rule.hooks.some((h) => typeof h.command === "string" && h.command.includes("scrylog-codex-hook")),
+      ),
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function isOpencodePluginRegistered(homeDir = homedir()): boolean {
+  const settingsPath = join(homeDir, ".config", "opencode", "opencode.json");
+  if (!existsSync(settingsPath)) return false;
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as OpenCodeSettings;
+    return (settings.plugin ?? []).some(
+      (plugin) => typeof plugin === "string" && plugin.includes(OPENCODE_PLUGIN_NAME),
+    );
+  } catch {
+    return false;
+  }
+}
+
 function backupBeforeWrite(path: string): void {
   if (!existsSync(path)) return;
   const bak = `${path}.bak`;
@@ -397,21 +543,21 @@ export async function runClaudeHooksInstall(options: GlobalCliOptions): Promise<
     mkdirSync(claudeDir, { recursive: true });
   }
 
+  if (isClaudeHooksInstalled()) {
+    process.stdout.write("Claude hooks are already installed.\n");
+    return;
+  }
+
   // Merge hooks — add scrylog entries without removing existing ones
   const existingHooks = settings.hooks ?? {};
   const updatedHooks: Record<string, ClaudeSettingsHookRule[]> = { ...existingHooks };
 
   for (const event of CLAUDE_HOOK_EVENTS) {
     const existing = updatedHooks[event] ?? [];
-    const alreadyInstalled = existing.some((rule) =>
-      rule.hooks.some((h) => typeof h.command === "string" && h.command.includes("scrylog-claude-hook")),
-    );
-    if (!alreadyInstalled) {
-      updatedHooks[event] = [
-        ...existing,
-        { matcher: "", hooks: [{ type: "command", command: hookBin }] },
-      ];
-    }
+    updatedHooks[event] = [
+      ...existing,
+      { matcher: "", hooks: [{ type: "command", command: hookBin }] },
+    ];
   }
 
   settings.hooks = updatedHooks;
@@ -490,22 +636,22 @@ export async function runCodexHooksInstall(options: GlobalCliOptions): Promise<v
     mkdirSync(codexDir, { recursive: true });
   }
 
+  if (isCodexHooksInstalled()) {
+    process.stdout.write("Codex hooks are already installed.\n");
+    return;
+  }
+
   // Merge hooks — add scrylog entries without removing existing ones
   const existingHooks = config.hooks ?? {};
   const updatedHooks: Record<string, CodexHookRule[]> = { ...existingHooks };
 
   for (const event of CODEX_HOOK_EVENTS) {
     const existing = updatedHooks[event] ?? [];
-    const alreadyInstalled = existing.some((rule) =>
-      rule.hooks.some((h) => typeof h.command === "string" && h.command.includes("scrylog-codex-hook")),
-    );
-    if (!alreadyInstalled) {
-      const entry: CodexHookRule = {
-        matcher: event === "UserPromptSubmit" || event === "Stop" ? undefined : "",
-        hooks: [{ type: "command", command: hookBin, ...(event === "Stop" ? { timeout: 30 } : {}) }],
-      };
-      updatedHooks[event] = [...existing, entry];
-    }
+    const entry: CodexHookRule = {
+      matcher: event === "UserPromptSubmit" || event === "Stop" ? undefined : "",
+      hooks: [{ type: "command", command: hookBin, ...(event === "Stop" ? { timeout: 30 } : {}) }],
+    };
+    updatedHooks[event] = [...existing, entry];
   }
 
   config.hooks = updatedHooks;
@@ -549,9 +695,7 @@ export async function runOpenCodeHooksInstall(options: GlobalCliOptions): Promis
 
   // Merge plugin entry without removing existing ones
   const existingPlugins = settings.plugin ?? [];
-  const alreadyInstalled = existingPlugins.some(
-    (plugin) => typeof plugin === "string" && plugin.includes(OPENCODE_PLUGIN_NAME),
-  );
+  const alreadyInstalled = isOpencodePluginRegistered();
 
   if (!alreadyInstalled) {
     settings.plugin = [...existingPlugins, OPENCODE_PLUGIN_NAME];

package/src/cli/index.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+import { CommanderError } from "commander";
+import { createProgram } from "./program";
+
+export async function main(argv = process.argv): Promise<void> {
+  await createProgram().parseAsync(argv);
+}
+
+if (import.meta.main) {
+  main().catch((error) => {
+    if (error instanceof CommanderError) {
+      process.exitCode = error.exitCode;
+      return;
+    }
+    process.stderr.write(`scrylog: fatal: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}

package/src/cli/program.ts

@@ -0,0 +1,175 @@
+import { Command } from "commander";
+import { getInstalledVersion } from "../shared/version";
+import {
+  runClaudeHooksInstall,
+  runCodexHooksInstall,
+  runConfigCommand,
+  runDaemonCommand,
+  runDoctor,
+  runLogsCommand,
+  runOpenCodeHooksInstall,
+  runSetupWizard,
+  runTokenCommand,
+} from "./commands";
+import type { GlobalCliOptions } from "./commands";
+
+export interface CliIO {
+  writeOut(message: string): void;
+  writeErr(message: string): void;
+}
+
+export type TuiLauncher = (configPath?: string, includeUnknown?: boolean) => void | Promise<void>;
+
+interface CliHandlers {
+  setup(options: GlobalCliOptions): void | Promise<void>;
+  doctor(options: GlobalCliOptions): void | Promise<void>;
+  daemon(action: string, options: GlobalCliOptions): void | Promise<void>;
+  config(action: string, options: GlobalCliOptions): void | Promise<void>;
+  token(target: "mcp" | "api" | "both", action: string, options: GlobalCliOptions): void | Promise<void>;
+  logs(options: GlobalCliOptions): void | Promise<void>;
+  claudeHooksInstall(options: GlobalCliOptions): void | Promise<void>;
+  codexHooksInstall(options: GlobalCliOptions): void | Promise<void>;
+  openCodeHooksInstall(options: GlobalCliOptions): void | Promise<void>;
+}
+
+export interface CreateProgramOptions {
+  io?: CliIO;
+  launchTui?: TuiLauncher;
+  handlers?: Partial<CliHandlers>;
+}
+
+interface ProgramOptions {
+  config?: string;
+  includeUnknown?: boolean;
+}
+
+const HELP_TEXT = `scrylog
+
+Usage:
+  scrylog [--config <path>] [--include-unknown]
+  scrylog setup [--config <path>]
+  scrylog doctor [--config <path>]
+  scrylog daemon <install|uninstall|start|stop|restart|status> [--config <path>]
+  scrylog config <show|path> [--config <path>]
+  scrylog token <mcp|api|both> <generate|rotate|clear> [--config <path>]
+  scrylog claude hooks install [--config <path>]
+  scrylog codex hooks install [--config <path>]
+  scrylog opencode hooks install [--config <path>]
+  scrylog logs [--config <path>]
+
+Options:
+  --config <path>      Load config from an explicit path
+  --include-unknown    Include sessions whose tool is unidentified
+  -h, --help           Show this help text
+  -V, --version        Show the installed scrylog version
+
+See also:
+  scrylogd            Background daemon (collects sessions and serves API/MCP)
+  scrylog-mcp         stdio MCP server that proxies daemon data to AI agents
+  scrylog-claude-hook Claude Code lifecycle hook binary
+  scrylog-codex-hook  Codex CLI lifecycle hook binary
+
+Notes:
+  Running scrylog with no subcommand launches the TUI dashboard.
+  'scrylog claude hooks install' configures Claude Code to emit lifecycle
+  hooks that scrylog uses for real-time session state tracking.
+  'scrylog codex hooks install' configures Codex CLI to emit lifecycle
+  hooks that scrylog uses for real-time session state tracking.
+  'scrylog opencode hooks install' registers the scrylog plugin in
+  OpenCode configuration for real-time session state tracking.
+`;
+
+export const TOKEN_USAGE = "Usage: scrylog token <mcp|api|both> <generate|rotate|clear>";
+
+export function parseTokenArgs(args: Array<string | undefined>): { target: "mcp" | "api" | "both"; action: string } {
+  const [target, action] = args;
+  if (!target) throw new Error(`Missing token target (mcp, api, or both). ${TOKEN_USAGE}`);
+  if (!action) throw new Error(`Missing token action (generate, rotate, or clear). ${TOKEN_USAGE}`);
+  if (target !== "mcp" && target !== "api" && target !== "both") {
+    throw new Error(`Invalid token target: ${target}. Must be mcp, api, or both. ${TOKEN_USAGE}`);
+  }
+  return { target, action };
+}
+
+function defaultIO(): CliIO {
+  return {
+    writeOut: (message) => process.stdout.write(message),
+    writeErr: (message) => process.stderr.write(message),
+  };
+}
+
+async function defaultLaunchTui(configPath?: string, includeUnknown = false): Promise<void> {
+  const tui = await import("../tui/index") as { launchTui: TuiLauncher };
+  await tui.launchTui(configPath, includeUnknown);
+}
+
+function globalOptions(command: Command): GlobalCliOptions {
+  const options = command.optsWithGlobals<ProgramOptions>();
+  return { configPath: options.config };
+}
+
+export function createProgram(options: CreateProgramOptions = {}): Command {
+  const io = options.io ?? defaultIO();
+  const launchTui = options.launchTui ?? defaultLaunchTui;
+  const handlers: CliHandlers = {
+    setup: runSetupWizard,
+    doctor: runDoctor,
+    daemon: runDaemonCommand,
+    config: runConfigCommand,
+    token: runTokenCommand,
+    logs: runLogsCommand,
+    claudeHooksInstall: runClaudeHooksInstall,
+    codexHooksInstall: runCodexHooksInstall,
+    openCodeHooksInstall: runOpenCodeHooksInstall,
+    ...options.handlers,
+  };
+
+  const program = new Command();
+  program
+    .name("scrylog")
+    .option("--config <path>", "Load config from an explicit path")
+    .option("--include-unknown", "Include sessions whose tool is unidentified")
+    .version(`scrylog ${getInstalledVersion()}`, "-V, --version", "Show the installed scrylog version")
+    .helpOption("-h, --help", "Show this help text")
+    .configureOutput({ writeOut: io.writeOut, writeErr: io.writeErr })
+    .configureHelp({ formatHelp: () => HELP_TEXT })
+    .showHelpAfterError("(see --help for usage)")
+    .exitOverride()
+    .argument("[command]")
+    .action(async (unknownCommand?: string) => {
+      if (unknownCommand) {
+        program.error(`error: unknown command '${unknownCommand}'`, { code: "commander.unknownCommand" });
+      }
+      const rootOptions = program.opts<ProgramOptions>();
+      await launchTui(rootOptions.config ?? process.env.SCRYLOG_CONFIG, rootOptions.includeUnknown ?? false);
+    });
+
+  const setup = program.command("setup").action(() => handlers.setup(globalOptions(setup)));
+  const doctor = program.command("doctor").action(() => handlers.doctor(globalOptions(doctor)));
+  const daemon = program
+    .command("daemon")
+    .argument("<action>", "install, uninstall, start, stop, restart, or status")
+    .action((action: string) => handlers.daemon(action, globalOptions(daemon)));
+  const config = program
+    .command("config")
+    .argument("<action>", "show or path")
+    .action((action: string) => handlers.config(action, globalOptions(config)));
+  const token = program
+    .command("token")
+    .argument("[target]", "mcp, api, or both")
+    .argument("[action]", "generate, rotate, or clear")
+    .action((target: string | undefined, action: string | undefined) => {
+      const parsed = parseTokenArgs([target, action]);
+      return handlers.token(parsed.target, parsed.action, globalOptions(token));
+    });
+  const logs = program.command("logs").action(() => handlers.logs(globalOptions(logs)));
+
+  const claudeInstall = program.command("claude").command("hooks").command("install");
+  claudeInstall.action(() => handlers.claudeHooksInstall(globalOptions(claudeInstall)));
+  const codexInstall = program.command("codex").command("hooks").command("install");
+  codexInstall.action(() => handlers.codexHooksInstall(globalOptions(codexInstall)));
+  const openCodeInstall = program.command("opencode").command("hooks").command("install");
+  openCodeInstall.action(() => handlers.openCodeHooksInstall(globalOptions(openCodeInstall)));
+
+  return program;
+}

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

@@ -133,7 +133,7 @@ export class ClaudeCollector implements Collector {
         // Don't remove hook-managed sessions — they have an authoritative lifecycle
         // managed by hooks (SessionEnd). Only remove transcript-sourced sessions.
         const existingSession = store.getSession(`claude:${transcript.sessionId}`);
-        if (existingSession?.detectionSource !== "claude-hook") {
+        if (existingSession?.detectionSource !== "claude-hook" && existingSession?.source === "standalone") {
           store.removeSession(`claude:${transcript.sessionId}`);
         }
       }
@@ -145,6 +145,16 @@ export class ClaudeCollector implements Collector {
   private processTranscript(transcript: import("./discovery").DiscoveredTranscript, _hasRunning: boolean): void {
     const store = this.store!;
     const config = this.config!;
+
+    // Do not re-add sessions that were explicitly ended via SessionEnd hook.
+    // The transcript file persists on disk after the session ends; without this
+    // guard, the discovery cycle would recreate the session immediately after
+    // the webhook removed it.
+    if (store.isLocalCommand(transcript.sessionId)) {
+      store.removeSession(`claude:${transcript.sessionId}`);
+      return;
+    }
+
     const existingSession = store.getSession(`claude:${transcript.sessionId}`);
     const watched = this.watched.get(transcript.path);
     if (

package/src/daemon/collectors/claude/discovery.ts

@@ -5,6 +5,7 @@ import type { ScrylogConfig } from "../../../shared/config";
 import type { Logger } from "../../../shared/logger";
 import { maybeRunCommand } from "../../../shared/utils";
 import { IS_WINDOWS } from "../../../shared/platform";
+import { isKnownClaudeProbePath } from "../../../shared/session-exclusions";
 
 export interface DiscoveredTranscript {
   sessionId: string;
@@ -17,28 +18,6 @@ export function getClaudeDir(config: ScrylogConfig): string {
   return config.claude.claudeDir ?? join(homedir(), ".claude");
 }
 
-// Internal: project slugs known to generate headless probe transcripts.
-// Third-party tools (e.g. CodexBar's ClaudeProbe on macOS) launch `claude`
-// periodically to run slash commands like `/usage` for their own telemetry.
-// Each run leaves a tiny transcript that scrylog misreads as an interactive
-// "working" session, cluttering the TUI with ghosts.
-// Not user-configurable — extend here when new probe sources are identified.
-// Patterns are matched case-insensitively with `*` wildcards; on tiers where
-// these tools do not run (Linux/WSL 2, Windows native) the list is a no-op.
-const KNOWN_PROBE_SLUG_GLOBS: readonly string[] = ["*CodexBar-ClaudeProbe*"];
-
-function matchesGlob(value: string, pattern: string): boolean {
-  const re = new RegExp(
-    "^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$",
-    "i",
-  );
-  return re.test(value);
-}
-
-function isKnownProbeSlug(slug: string): boolean {
-  return KNOWN_PROBE_SLUG_GLOBS.some((pattern) => matchesGlob(slug, pattern));
-}
-
 /**
  * Decodes a Claude project slug (e.g. "-Volumes-Files-Workspace-Projects-other-scrylog-feature-daemon")
  * back to an absolute filesystem path ("/Volumes/Files/Workspace/Projects/other/scrylog-feature-daemon").
@@ -87,7 +66,7 @@ export function discoverTranscripts(claudeDir: string, hookManagedIds?: Readonly
       // Skip project directories emitted by known headless probe tools
       // (e.g. CodexBar's ClaudeProbe). Their transcripts are not interactive
       // sessions and would otherwise show as permanent "working" ghosts.
-      if (isKnownProbeSlug(projectSlug)) continue;
+      if (isKnownClaudeProbePath(projectSlug)) continue;
       const projectPath = join(projectsDir, projectSlug);
       try {
         if (!statSync(projectPath).isDirectory()) continue;

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

@@ -122,14 +122,14 @@ function hasAnsweredRequestUserInputWork(entries: TranscriptEntry[]): boolean {
   return false;
 }
 
-function preserveLocationMetadata(model: SessionModel, existing?: SessionModel): SessionModel {
+export function preserveLocationMetadata(model: SessionModel, existing?: SessionModel): SessionModel {
   if (!existing) return model;
-
   return {
     ...model,
     source: existing.source,
     project: existing.project ?? model.project,
     tmux: existing.tmux ?? model.tmux,
+    herdr: existing.herdr ?? model.herdr,
     legacyPaneId: existing.legacyPaneId ?? model.legacyPaneId,
     processTree: existing.processTree ?? model.processTree,
     processChain: existing.processChain ?? model.processChain,
@@ -267,7 +267,7 @@ export class CodexCollector implements Collector {
         // Don't remove hook-managed sessions — they have an authoritative lifecycle
         // managed by hooks. Only remove transcript-sourced sessions.
         const existingSession = store.getSession(`codex:${transcript.sessionId}`);
-        if (existingSession?.detectionSource !== "codex-hook") {
+        if (existingSession?.detectionSource !== "codex-hook" && existingSession?.source === "standalone") {
           store.removeSession(`codex:${transcript.sessionId}`);
         }
       }

package/src/daemon/collectors/git.ts

@@ -18,12 +18,70 @@ interface GitCommandContext {
   workTree?: string;
 }
 
+/**
+ * Freshness tracking for cached ProjectInfo entries. The branch (and only the
+ * branch) goes stale when the repo's HEAD file changes; everything else
+ * (displayName, remote, worktree status) is stable per cwd. We fingerprint the
+ * resolved HEAD file — works for regular repos, worktrees, and WSL-backed
+ * Windows checkouts, and never spawns a git subprocess.
+ */
+interface FreshnessMeta {
+  headPath?: string;
+  headMtimeMs?: number;
+}
+
+const freshnessByProject = new WeakMap<ProjectInfo, FreshnessMeta>();
+
+function freshenProject(project: ProjectInfo, gitMarkerDirectory: string | null): ProjectInfo {
+  if (!gitMarkerDirectory) return project;
+  const headPath = resolveHeadPath(gitMarkerDirectory);
+  if (!headPath) return project;
+  const mtime = readHeadMtime(headPath);
+  if (mtime === undefined) return project;
+  freshnessByProject.set(project, { headPath, headMtimeMs: mtime });
+  return project;
+}
+
+function resolveHeadPath(gitMarkerDirectory: string): string | undefined {
+  const context = resolveGitCommandContext(gitMarkerDirectory);
+  const gitDir = context.gitDir
+    ? resolve(context.cwd, context.gitDir)
+    : join(gitMarkerDirectory, ".git");
+  return join(gitDir, "HEAD");
+}
+
+function readHeadMtime(headPath: string | undefined): number | undefined {
+  if (!headPath) return undefined;
+  try {
+    return statSync(headPath).mtimeMs;
+  } catch {
+    return undefined;
+  }
+}
+
+function isFreshnessCurrent(project: ProjectInfo): boolean {
+  if (!project.isGitRepository) return true;
+  const meta = freshnessByProject.get(project);
+  if (!meta?.headPath || meta.headMtimeMs === undefined) return false;
+  return readHeadMtime(meta.headPath) === meta.headMtimeMs;
+}
+
+function invalidateCachedProject(cache: Map<string, ProjectInfo>, project: ProjectInfo): void {
+  for (const [key, value] of [...cache]) {
+    if (value === project) cache.delete(key);
+  }
+  freshnessByProject.delete(project);
+}
+
 export function resolveProjectInfo(currentPath: string, cache = new Map<string, ProjectInfo>(), timeoutMs?: number): ProjectInfo {
   const normalizedPath = normalizePathForLookup(currentPath);
   const cached = lookupCachedProject(normalizedPath, cache);
-  if (cached) {
+  if (cached && isFreshnessCurrent(cached)) {
     return cached;
   }
+  if (cached) {
+    invalidateCachedProject(cache, cached);
+  }
 
   const visited: string[] = [];
   const searchStart = resolveSearchStart(normalizedPath);
@@ -41,7 +99,7 @@ export function resolveProjectInfo(currentPath: string, cache = new Map<string,
     cache.set(cacheKey, project);
   }
 
-  return project;
+  return project.isGitRepository ? freshenProject(project, gitMarkerDirectory) : project;
 }
 
 export function buildCompactProjectLabel(project: Pick<ProjectInfo, "displayName" | "isGitRepository" | "branch" | "isWorktree">): string {