@scrylog/cli 0.1.0

package/src/daemon/store.ts

@@ -0,0 +1,535 @@
+import { EventEmitter } from "node:events";
+import type { Logger } from "../shared/logger";
+import { NOOP_LOGGER } from "../shared/logger";
+import type { CollectorStatus, DaemonState, SessionInfo, SessionModel, StoreEvent } from "../shared/types";
+import type { RetentionConfig } from "../shared/config";
+
+/**
+ * In-memory state store for the daemon.
+ * Maintains all session data and emits typed StoreEvent events on changes.
+ */
+export class DaemonStore extends EventEmitter {
+  private state: DaemonState = {
+    tmuxSessions: [],
+    sessions: [],
+    collectorStatus: {},
+    usage: { providers: [], lastRefreshedAt: 0 },
+    startedAt: Date.now(),
+    refreshedAt: 0,
+  };
+
+  /** Maps SDK process PID → instance URL for PID-ancestry-based deduplication */
+  private sdkPids = new Map<number, string>();
+
+  /** Session IDs that were deliberately excluded as local-command (batch) transcripts */
+  private localCommandIds = new Map<string, number>();
+
+  /** Session IDs whose idle transition was suppressed because of active children.
+   * When the last child goes inactive, the parent is transitioned to idle. */
+  private suppressedIdle = new Set<string>();
+
+  constructor(private readonly logger: Logger = NOOP_LOGGER) {
+    super();
+  }
+
+  // ── Reads ──────────────────────────────────────────────────────────────────
+
+  getState(): Readonly<DaemonState> {
+    return this.state;
+  }
+
+  getSessions(): SessionModel[] {
+    return [...this.state.sessions];
+  }
+
+  getSession(id: string): SessionModel | undefined {
+    return this.state.sessions.find((s) => s.id === id);
+  }
+
+  getTmuxSessions(): SessionInfo[] {
+    return [...this.state.tmuxSessions];
+  }
+
+  // ── Writes ─────────────────────────────────────────────────────────────────
+
+  /** Replace the full sessions list and emit diff events */
+  setSessions(sessions: SessionModel[]): void {
+    // Prune suppressedIdle entries that no longer exist
+    const sessionIds = new Set(sessions.map((s) => s.id));
+    for (const id of this.suppressedIdle) {
+      if (!sessionIds.has(id)) {
+        this.suppressedIdle.delete(id);
+      }
+    }
+
+    const previous = new Map(this.state.sessions.map((s) => [s.id, s]));
+    const next = new Map(sessions.map((s) => [s.id, s]));
+
+    // Removed
+    for (const [id] of previous) {
+      if (!next.has(id)) {
+        this.logger.info("store", "Session removed", { event: "session.removed", sessionId: id });
+        this.emit("store:event", { type: "session:removed", sessionId: id } satisfies StoreEvent);
+      }
+    }
+
+    // Added or updated
+    for (const [id, session] of next) {
+      if (!previous.has(id)) {
+        this.logger.info("store", "Session added", { event: "session.added", sessionId: id, tool: session.tool, state: session.state });
+        this.emit("store:event", { type: "session:added", session } satisfies StoreEvent);
+      } else {
+        const prev = previous.get(id)!;
+        if (prev.state !== session.state) {
+          this.logger.info("store", "Session state changed", {
+            event: "session.state_changed",
+            sessionId: id,
+            previousState: prev.state,
+            state: session.state,
+            tool: session.tool,
+          });
+        } else {
+          this.logger.debug("store", "Session updated", { event: "session.updated", sessionId: id, state: session.state });
+        }
+        this.emit("store:event", { type: "session:updated", session } satisfies StoreEvent);
+      }
+    }
+
+    this.state = { ...this.state, sessions, refreshedAt: Date.now() };
+    this.emit("store:event", { type: "state:refreshed", timestamp: this.state.refreshedAt } satisfies StoreEvent);
+  }
+
+  /** Upsert a single session */
+  upsertSession(incoming: SessionModel): void {
+    const existing = this.state.sessions.find((s) => s.id === incoming.id);
+
+    // If the existing session has been enriched with tmux context (legacyPaneId
+    // is set) but the incoming write does not carry tmux context, preserve the
+    // 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?.legacyPaneId && !incoming.legacyPaneId) {
+      const stableForMs = existing.state !== incoming.state ? 0 : existing.stableForMs;
+      session = {
+        ...incoming,
+        source: existing.source,
+        project: existing.project ?? incoming.project,
+        tmux: existing.tmux,
+        legacyPaneId: existing.legacyPaneId,
+        processTree: existing.processTree,
+        processChain: existing.processChain,
+        sample: existing.sample,
+        stableForMs,
+        panePid: existing.panePid,
+        tty: existing.tty,
+        paneTitle: existing.paneTitle,
+        currentCommand: existing.currentCommand,
+        currentPath: existing.currentPath ?? incoming.currentPath,
+      };
+    } else if (existing?.tmux && !incoming.tmux && existing.id === incoming.id) {
+      // Debug: detect when tmux enrichment would be lost because legacyPaneId
+      // guard didn't trigger but tmux data exists on existing session
+      this.logger.warn("store", "TMUX enrichment at risk", {
+        event: "session.enrichment_at_risk",
+        sessionId: incoming.id,
+        existingSource: existing.source,
+        incomingSource: incoming.source,
+        existingLegacyPaneId: existing.legacyPaneId,
+        incomingLegacyPaneId: incoming.legacyPaneId,
+        existingTmux: !!existing.tmux,
+        incomingTmux: !!incoming.tmux,
+        existingDetectionSource: existing.detectionSource,
+        incomingDetectionSource: incoming.detectionSource,
+      });
+    }
+
+    // Preserve stateChangedAt from the stored session when the incoming model
+    // doesn't carry it (e.g. built by processTranscript from file state only).
+    if (existing && !session.stateChangedAt && existing.stateChangedAt) {
+      session = { ...session, stateChangedAt: existing.stateChangedAt };
+    }
+
+    if (existing && existing.state !== session.state) {
+      const now = Date.now();
+      const hasActiveChildren = session.parentSessionId === undefined
+        && session.state === "idle"
+        && (existing.state === "working" || existing.state === "waiting-input")
+        && this.state.sessions.some(
+          (s) => s.parentSessionId === session.id
+            && (s.state === "working" || s.state === "waiting-input"),
+        );
+      if (hasActiveChildren) {
+        this.suppressedIdle.add(session.id);
+        session = { ...session, state: existing.state, stateChangedAt: existing.stateChangedAt };
+      } else {
+        this.suppressedIdle.delete(session.id);
+        const isGracePeriodIdleToWorking = existing.state === "idle"
+          && session.state === "working"
+          && existing.lastChildActiveAt
+          && (now - existing.lastChildActiveAt) < 1500;
+
+        if (session.state === "working") {
+          session = {
+            ...session,
+            stableForMs: 0,
+            stateChangedAt: now,
+            lastWorkingChangedAt: isGracePeriodIdleToWorking
+              ? (existing.lastWorkingChangedAt ?? now)
+              : now,
+          };
+        } else {
+          session = { ...session, stableForMs: 0, stateChangedAt: now };
+
+          if (session.state === "waiting-input" || session.state === "error") {
+            session = { ...session, lastWorkingChangedAt: undefined, lastChildActiveAt: undefined };
+          }
+        }
+      }
+    }
+
+    if (existing) {
+      if (existing.state !== session.state) {
+        this.logger.info("store", "Session state changed", {
+          event: "session.state_changed",
+          sessionId: session.id,
+          previousState: existing.state,
+          state: session.state,
+          tool: session.tool,
+        });
+      } else {
+        this.logger.debug("store", "Session updated", { event: "session.updated", sessionId: session.id, state: session.state });
+      }
+      this.state = {
+        ...this.state,
+        sessions: this.state.sessions.map((s) => (s.id === session.id ? session : s)),
+        refreshedAt: Date.now(),
+      };
+      this.emit("store:event", { type: "session:updated", session } satisfies StoreEvent);
+    } else {
+      if (!session.stateChangedAt) {
+        session = { ...session, stateChangedAt: Date.now() };
+      }
+      if (session.state === "working" && !session.lastWorkingChangedAt) {
+        session = { ...session, lastWorkingChangedAt: session.stateChangedAt };
+      }
+      this.logger.info("store", "Session added", { event: "session.added", sessionId: session.id, tool: session.tool, state: session.state });
+      this.state = {
+        ...this.state,
+        sessions: [...this.state.sessions, session],
+        refreshedAt: Date.now(),
+      };
+      this.emit("store:event", { type: "session:added", session } satisfies StoreEvent);
+    }
+
+    // Track lastChildActiveAt on parent when a child session transitions
+    // away from "working" or "waiting-input" and no other children are active.
+    if (session.parentSessionId && existing && (existing.state === "working" || existing.state === "waiting-input") && existing.state !== session.state) {
+      const anyOtherActiveChildren = this.state.sessions.some(
+        (s) => s.parentSessionId === session.parentSessionId
+          && s.id !== session.id
+          && (s.state === "working" || s.state === "waiting-input"),
+      );
+      if (!anyOtherActiveChildren) {
+        const parent = this.state.sessions.find((s) => s.id === session.parentSessionId);
+        if (parent) {
+          let updatedParent: SessionModel;
+          if (this.suppressedIdle.has(parent.id)) {
+            this.suppressedIdle.delete(parent.id);
+            updatedParent = {
+              ...parent,
+              state: "idle" as SessionModel["state"],
+              stateChangedAt: Date.now(),
+              stableForMs: 0,
+              lastChildActiveAt: Date.now(),
+            };
+            this.logger.info("store", "Session state changed", {
+              event: "session.state_changed",
+              sessionId: parent.id,
+              previousState: parent.state,
+              state: "idle",
+              tool: parent.tool,
+            });
+          } else {
+            updatedParent = { ...parent, lastChildActiveAt: Date.now() };
+          }
+          this.state = {
+            ...this.state,
+            sessions: this.state.sessions.map((s) => s.id === parent.id ? updatedParent : s),
+            refreshedAt: Date.now(),
+          };
+          this.emit("store:event", { type: "session:updated", session: updatedParent } satisfies StoreEvent);
+        }
+      }
+    }
+  }
+
+  /** Remove a session by id */
+  removeSession(sessionId: string): void {
+    const session = this.state.sessions.find((s) => s.id === sessionId);
+    if (!session) {
+      return;
+    }
+
+    const parentId = session.parentSessionId;
+
+    this.logger.info("store", "Session removed", { event: "session.removed", sessionId });
+    this.state = {
+      ...this.state,
+      sessions: this.state.sessions.filter((s) => s.id !== sessionId),
+      refreshedAt: Date.now(),
+    };
+    this.emit("store:event", { type: "session:removed", sessionId } satisfies StoreEvent);
+
+    this.suppressedIdle.delete(sessionId);
+
+    if (parentId && this.suppressedIdle.has(parentId)) {
+      const anyOtherActiveChildren = this.state.sessions.some(
+        (s) => s.parentSessionId === parentId && (s.state === "working" || s.state === "waiting-input"),
+      );
+      if (!anyOtherActiveChildren) {
+        this.suppressedIdle.delete(parentId);
+        const parent = this.state.sessions.find((s) => s.id === parentId);
+        if (parent) {
+          const updatedParent: SessionModel = {
+            ...parent,
+            state: "idle" as SessionModel["state"],
+            stateChangedAt: Date.now(),
+            stableForMs: 0,
+          };
+          this.state = {
+            ...this.state,
+            sessions: this.state.sessions.map((s) => s.id === parentId ? updatedParent : s),
+            refreshedAt: Date.now(),
+          };
+          this.logger.info("store", "Session state changed", {
+            event: "session.state_changed",
+            sessionId: parentId,
+            previousState: parent.state,
+            state: "idle",
+            tool: parent.tool,
+          });
+          this.emit("store:event", { type: "session:updated", session: updatedParent } satisfies StoreEvent);
+        }
+      }
+    }
+  }
+
+  /**
+   * Remove tmux enrichment from any sessions currently bound to a pane, except
+   * for an optional winning session that should retain the binding.
+   */
+  clearTmuxBindingForPane(paneId: string, exceptSessionId?: string): void {
+    let changed = false;
+    const sessions = this.state.sessions.map((session) => {
+      const boundPaneId = session.legacyPaneId ?? session.tmux?.pane;
+      if (boundPaneId !== paneId || session.id === exceptSessionId) {
+        return session;
+      }
+
+      if (
+        session.detectionSource !== "opencode-sdk"
+        && session.detectionSource !== "opencode-hook"
+        && session.detectionSource !== "opencode-db"
+        && session.detectionSource !== "claude-hook"
+        && session.detectionSource !== "claude-transcript"
+        && session.detectionSource !== "codex-hook"
+        && session.detectionSource !== "codex-transcript"
+      ) {
+        return session;
+      }
+
+      changed = true;
+      return {
+        ...session,
+        source: "standalone" as const,
+        tmux: undefined,
+        legacyPaneId: undefined,
+        processTree: undefined,
+        processChain: undefined,
+        sample: undefined,
+        stableForMs: undefined,
+        panePid: undefined,
+        tty: undefined,
+        paneTitle: undefined,
+        currentCommand: undefined,
+      };
+    });
+
+    if (!changed) {
+      return;
+    }
+
+    this.state = {
+      ...this.state,
+      sessions,
+      refreshedAt: Date.now(),
+    };
+  }
+
+  /** Update usage state and emit event */
+  setUsage(usage: import("../usage/types").UsageState): void {
+    this.state = { ...this.state, usage };
+    this.emit("store:event", { type: "usage:updated", usage } satisfies StoreEvent);
+  }
+
+  /** Update tmux session list */
+  setTmuxSessions(sessions: SessionInfo[]): void {
+    this.state = { ...this.state, tmuxSessions: sessions };
+  }
+
+  /**
+   * Snapshot of process data currently held by the process collector, if any.
+   * Used by other collectors as a fallback when platform tools (pgrep, lsof)
+   * are unavailable.
+   */
+  private processCollector?: { processes: { pid: number; command: string }[] };
+
+  registerProcessCollector(collector: { processes: { pid: number; command: string }[] }): void {
+    this.processCollector = collector;
+  }
+
+  getCollectorProcessSnapshot(): { pid: number; command: string }[] {
+    return this.processCollector?.processes ?? [];
+  }
+
+  /** Update collector status */
+  setCollectorStatus(name: string, status: Partial<CollectorStatus>): void {
+    this.state = {
+      ...this.state,
+      collectorStatus: {
+        ...this.state.collectorStatus,
+        [name]: {
+          ...{ name, running: false, lastRunAt: 0 },
+          ...this.state.collectorStatus[name],
+          ...status,
+        },
+      },
+    };
+  }
+
+  /** Emit a store error event */
+  reportError(source: string, message: string): void {
+    this.logger.warn("store", "Collector error", { event: "collector.error", collector: source, errorMessage: message });
+    this.emit("store:event", { type: "error", source, message } satisfies StoreEvent);
+  }
+
+  // ── SDK PID registry ───────────────────────────────────────────────────────
+
+  /** Register a known SDK process PID (used for PID-ancestry dedup) */
+  registerSdkPid(pid: number, instanceUrl: string): void {
+    this.sdkPids.set(pid, instanceUrl);
+  }
+
+  /** Unregister a SDK process PID */
+  unregisterSdkPid(pid: number): void {
+    this.sdkPids.delete(pid);
+  }
+
+  /** Get the current set of known SDK process PIDs */
+  getSdkPids(): ReadonlyMap<number, string> {
+    return this.sdkPids;
+  }
+
+  // ── Local-command exclusion registry ──────────────────────────────────────
+
+  /** Mark a session as a deliberately-excluded local-command (batch) transcript */
+  markLocalCommand(sessionId: string): void {
+    this.localCommandIds.set(sessionId, Date.now());
+  }
+
+  /** Returns true when the session was excluded as a local-command transcript */
+  isLocalCommand(sessionId: string): boolean {
+    return this.localCommandIds.has(sessionId);
+  }
+
+  /** Apply bounded retention to inactive sessions and local-command markers. */
+  applyRetention(retention: RetentionConfig, now = Date.now()): void {
+    this.pruneLocalCommandIds(retention, now);
+
+    const active = (session: SessionModel) => session.state === "working" || session.state === "waiting-input";
+    const maxAgeMs = retention.standaloneMaxAgeHours > 0
+      ? retention.standaloneMaxAgeHours * 60 * 60 * 1000
+      : 0;
+    const removeIds = new Set<string>();
+
+    if (maxAgeMs > 0) {
+      for (const session of this.state.sessions) {
+        if (active(session)) continue;
+        if (session.source !== "standalone") continue;
+        if (now - session.lastActivity > maxAgeMs) {
+          removeIds.add(session.id);
+        }
+      }
+    }
+
+    const maxSessions = retention.maxSessions;
+    if (maxSessions > 0) {
+      const survivors = this.state.sessions.filter((session) => !removeIds.has(session.id));
+      const overflow = survivors.length - maxSessions;
+      if (overflow > 0) {
+        const candidates = survivors
+          .filter((session) => !active(session))
+          .sort((a, b) => a.lastActivity - b.lastActivity);
+        for (const session of candidates.slice(0, overflow)) {
+          removeIds.add(session.id);
+        }
+      }
+    }
+
+    if (removeIds.size === 0) return;
+
+    for (const id of removeIds) {
+      this.suppressedIdle.delete(id);
+    }
+
+    this.state = {
+      ...this.state,
+      sessions: this.state.sessions.filter((session) => !removeIds.has(session.id)),
+      refreshedAt: now,
+    };
+    for (const id of removeIds) {
+      this.logger.info("store", "Session pruned by retention", { event: "retention.pruned", sessionId: id });
+      this.emit("store:event", { type: "session:removed", sessionId: id } satisfies StoreEvent);
+    }
+    this.emit("store:event", { type: "state:refreshed", timestamp: now } satisfies StoreEvent);
+  }
+
+  private pruneLocalCommandIds(retention: RetentionConfig, now: number): void {
+    const ttlMs = retention.localCommandTtlHours * 60 * 60 * 1000;
+    for (const [sessionId, markedAt] of this.localCommandIds) {
+      if (now - markedAt > ttlMs) {
+        this.localCommandIds.delete(sessionId);
+      }
+    }
+  }
+
+  /** Rebuild childSessionIds on parent sessions that have children */
+  syncChildSessionIds(): void {
+    const sessions = this.state.sessions;
+    const childMap = new Map<string, string[]>();
+    for (const s of sessions) {
+      if (!s.parentSessionId) continue;
+      const siblings = childMap.get(s.parentSessionId) ?? [];
+      if (!siblings.includes(s.id)) siblings.push(s.id);
+      childMap.set(s.parentSessionId, siblings);
+    }
+
+    for (const [parentId, childIds] of childMap) {
+      const parent = this.getSession(parentId);
+      if (!parent) continue;
+
+      const sorted = [...childIds].sort();
+      const existing = [...(parent.childSessionIds ?? [])].sort();
+      if (JSON.stringify(sorted) !== JSON.stringify(existing)) {
+        this.upsertSession({ ...parent, childSessionIds: sorted });
+      }
+    }
+  }
+
+  // ── Typed event helper ─────────────────────────────────────────────────────
+
+  onEvent(listener: (event: StoreEvent) => void): () => void {
+    this.on("store:event", listener);
+    return () => this.off("store:event", listener);
+  }
+}

package/src/detect.ts

@@ -0,0 +1,143 @@
+import type { DetectionReason, PaneSample, ProcessInfo, ToolKind } from "./types";
+import { compactWhitespace, isMostlyUiNoise, isOpencodeFooterLine, isSuggestionStyleText, pickMeaningfulTail, stripAnsiAndUi } from "./shared/utils";
+
+const ACTIVITY_PATTERN = /(thinking|generating|executing|applying|running|streaming|analyzing|^working\s*\(|background terminal running|waited for background terminal|creating|created\s+\d+)/i;
+const PROMPT_PATTERN = /(press enter|continue\?|y\/n|confirm(?:a|as|ar)?\b|waiting for input|type your own answer|send a message|^>\s|^>\b|^\?\s|pregunta clave|^\-\s+¿|^¿)/im;
+const COMPLETION_PATTERN = /(worked for\s+\d|all done|completed|finished|done\b|se cre[oó]\b|cada archivo contiene|ya se escribieron\s+\d+\s+a\s+\d+|contin[uú]o hasta que termine|proceso ya pas[oó]|termin[oó]\s+bien)/i;
+
+const TOOL_PATTERNS: Array<{ tool: ToolKind; regex: RegExp; label: string }> = [
+  { tool: "opencode", regex: /(^|\b)(opencode)(\b|$)/i, label: "process matched opencode" },
+  { tool: "claude", regex: /(?:^|\s|\/)(claude)(?:\s|$)/i, label: "process matched claude" },
+  { tool: "codex", regex: /(^|\b)(codexcli|codex)(\b|$)/i, label: "process matched codex" },
+  { tool: "copilotcli", regex: /(^|\b)(copilotcli|copilot)(\b|$)/i, label: "process matched copilot" },
+];
+
+const SHELL_PATTERN = /(^|\b)(bash|zsh|fish|sh|tmux)(\b|$)/i;
+
+export function detectTool(currentCommand: string, processTree: ProcessInfo[]): { tool: ToolKind; reasons: DetectionReason[] } {
+  const reasons: DetectionReason[] = [];
+  const candidates = [currentCommand, ...processTree.map((process) => `${process.comm} ${process.command}`)];
+
+  for (const candidate of candidates) {
+    for (const pattern of TOOL_PATTERNS) {
+      if (pattern.regex.test(candidate)) {
+        reasons.push({
+          label: pattern.label,
+          detail: compactWhitespace(candidate),
+        });
+        return { tool: pattern.tool, reasons };
+      }
+    }
+  }
+
+  if (candidates.some((candidate) => SHELL_PATTERN.test(candidate))) {
+    reasons.push({
+      label: "shell foreground detected",
+      detail: compactWhitespace(currentCommand || processTree[0]?.command || "shell"),
+    });
+    return { tool: "shell", reasons };
+  }
+
+  reasons.push({
+    label: "no supported tool match",
+    detail: compactWhitespace(candidates.join(" | ")) || "no command context",
+  });
+  return { tool: "unknown", reasons };
+}
+
+export function previewSignals(sample: PaneSample | null): DetectionReason[] {
+  if (!sample || sample.lines.length === 0) {
+    return [];
+  }
+
+  const normalizedLines = sample.lines.map((line) => compactWhitespace(stripAnsiAndUi(line))).filter(Boolean);
+  const recentLines = normalizedLines.slice(-8);
+  const tailWindow = recentLines.filter((line) => !isMostlyUiNoise(line));
+  const preview = pickMeaningfulTail(tailWindow, sample.preview);
+  const reasons: DetectionReason[] = [];
+  const activityMatch = findMatchingLine(tailWindow, ACTIVITY_PATTERN);
+  const promptMatch = findMatchingLine(tailWindow, PROMPT_PATTERN, { excludeSuggestions: true });
+  const completionMatch = findMatchingLine(tailWindow, COMPLETION_PATTERN);
+  const opencodeFooterMatch = findOpencodeFooterSignal(recentLines);
+
+  if (activityMatch) {
+    reasons.push({ label: "activity keywords", detail: activityMatch });
+  }
+
+  if (promptMatch) {
+    reasons.push({ label: "input prompt keywords", detail: promptMatch });
+  }
+
+  if (completionMatch) {
+    reasons.push({ label: "completion keywords", detail: completionMatch });
+  }
+
+  if (opencodeFooterMatch) {
+    reasons.push({ label: "opencode footer activity", detail: opencodeFooterMatch });
+  }
+
+  const lastMeaningful = tailWindow.at(-1) ?? preview;
+  if (!isSuggestionStyleText(lastMeaningful) && (/[:>]\s*$/.test(lastMeaningful) || /^>\s+/.test(lastMeaningful) || /^\?\s+/.test(lastMeaningful))) {
+    reasons.push({ label: "prompt-like tail", detail: lastMeaningful });
+  }
+
+  return reasons;
+}
+
+export function getPreviewMatchPositions(sample: PaneSample | null): { activityIndex: number; promptIndex: number; completionIndex: number } {
+  if (!sample || sample.lines.length === 0) {
+    return { activityIndex: -1, promptIndex: -1, completionIndex: -1 };
+  }
+
+  const normalizedLines = sample.lines.map((line) => compactWhitespace(stripAnsiAndUi(line)));
+  let activityIndex = -1;
+  let promptIndex = -1;
+  let completionIndex = -1;
+
+  for (let index = 0; index < normalizedLines.length; index += 1) {
+    const line = normalizedLines[index] ?? "";
+    if (!line) {
+      continue;
+    }
+    if (ACTIVITY_PATTERN.test(line) || isOpencodeFooterLine(line)) {
+      activityIndex = index;
+    }
+    if (isMostlyUiNoise(line) && !isOpencodeFooterLine(line)) {
+      continue;
+    }
+    if (PROMPT_PATTERN.test(line) && !isSuggestionStyleText(line)) {
+      promptIndex = index;
+    }
+    if (COMPLETION_PATTERN.test(line)) {
+      completionIndex = index;
+    }
+  }
+
+  return { activityIndex, promptIndex, completionIndex };
+}
+
+function findMatchingLine(lines: string[], pattern: RegExp, options?: { excludeSuggestions?: boolean }): string | null {
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index] ?? "";
+    if (options?.excludeSuggestions && isSuggestionStyleText(line)) {
+      continue;
+    }
+    if (pattern.test(line)) {
+      return line;
+    }
+  }
+
+  return null;
+}
+
+function findOpencodeFooterSignal(lines: string[]): string | null {
+  const tailLines = lines.slice(-3);
+  for (let index = tailLines.length - 1; index >= 0; index -= 1) {
+    const line = tailLines[index] ?? "";
+    if (isOpencodeFooterLine(line)) {
+      return line;
+    }
+  }
+
+  return null;
+}