@scrylog/cli 0.2.0 → 0.3.0

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

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 {

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-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),