refactor(usage): split AI-usage scanners and stores under the max-lines budget (#14668)

The three usage scanners and their stores, plus the renderer usage-overview
model, each carried a file-level `eslint-disable max-lines` and had grown to
338-769 counted lines against a 300-line budget. AGENTS.md calls for splitting
rather than suppressing, and config/max-lines-baseline.txt is a shrink-only
ratchet, so this removes all seven suppressions and prunes their entries
(341 -> 334).

Each file is cut along the seams it already had -- and that several of the
suppression comments named out loud: filesystem discovery / record parsing /
attribution / aggregation for the scanners, and pricing policy / scope filters /
rollups / session rows / automation attribution for the stores.

Pure move, no behavior change. Code is relocated verbatim; the only edits are
import plumbing and, where a private class method became a free function, the
mechanical `this.state` -> `state` parameter threading. Every converted call
site passes `this.state` at call time and the automation path takes a live
`getState: () => this.state` getter, so no state is snapshotted. No barrel
exports: each new module owns real logic and importers point at the owner.

Verified: oxlint clean, ratchet passes, typecheck clean, full unit suite green
(remaining failures are pre-existing load flakes in untouched files, each green
when re-run serially), no import cycles among the 64 affected modules, and a
statement-level diff of every split confirms the moves are verbatim.

src/main/opencode-usage/opencode-usage-worktree-attribution.ts

@@ -0,0 +1,122 @@
+import { realpath } from 'node:fs/promises'
+import { posix, win32 } from 'node:path'
+import { areWorktreePathsEqual } from '../ipc/worktree-logic'
+import { canonicalizeUsageWorktreePaths } from '../usage-worktree-canonicalizer'
+import {
+  looksLikeWindowsPath,
+  normalizeComparablePath,
+  normalizeFsPath
+} from '../usage/usage-path-comparison'
+import type { UsageScanWorktreeRef } from '../usage/usage-provider-contract'
+import type { OpenCodeUsageAttributedEvent, OpenCodeUsageParsedEvent } from './types'
+
+export type OpenCodeUsageWorktreeRef = UsageScanWorktreeRef
+
+function getDefaultProjectLabel(cwd: string | null): string {
+  if (!cwd) {
+    return 'Unknown location'
+  }
+  const parts = cwd.replace(/\\/g, '/').split('/').filter(Boolean)
+  if (parts.length >= 2) {
+    return parts.slice(-2).join('/')
+  }
+  return parts.at(-1) ?? cwd
+}
+
+function localDayFromTimestamp(timestamp: string): string | null {
+  const parsed = new Date(timestamp)
+  if (Number.isNaN(parsed.getTime())) {
+    return null
+  }
+  const year = parsed.getFullYear()
+  const month = String(parsed.getMonth() + 1).padStart(2, '0')
+  const day = String(parsed.getDate()).padStart(2, '0')
+  return `${year}-${month}-${day}`
+}
+
+function isContainingPath(candidatePath: string, targetPath: string): boolean {
+  const useWin32 = looksLikeWindowsPath(candidatePath) || looksLikeWindowsPath(targetPath)
+  const relativePath = useWin32
+    ? win32.relative(candidatePath, targetPath)
+    : posix.relative(candidatePath, targetPath)
+  if (!relativePath) {
+    return true
+  }
+  const isAbsoluteRelative = useWin32
+    ? win32.isAbsolute(relativePath)
+    : posix.isAbsolute(relativePath)
+  const parentPrefix = useWin32 ? `..${win32.sep}` : `..${posix.sep}`
+  // Why: `..name` is a valid child path; only `..` and `../...` escape.
+  return (
+    !isAbsoluteRelative &&
+    relativePath !== '..' &&
+    !relativePath.startsWith(parentPrefix) &&
+    relativePath !== '.'
+  )
+}
+
+export async function buildWorktreesWithCanonicalPaths(
+  worktrees: OpenCodeUsageWorktreeRef[]
+): Promise<(OpenCodeUsageWorktreeRef & { canonicalPath: string })[]> {
+  return canonicalizeUsageWorktreePaths(worktrees, canonicalizePath)
+}
+
+async function canonicalizePath(pathValue: string): Promise<string> {
+  try {
+    return normalizeFsPath(await realpath(pathValue))
+  } catch {
+    return normalizeFsPath(pathValue)
+  }
+}
+
+function findContainingWorktree(
+  cwd: string,
+  worktrees: (OpenCodeUsageWorktreeRef & { canonicalPath: string })[]
+): OpenCodeUsageWorktreeRef | null {
+  const normalizedCwd = normalizeFsPath(cwd)
+  for (const worktree of worktrees) {
+    if (areWorktreePathsEqual(worktree.canonicalPath, normalizedCwd)) {
+      return worktree
+    }
+    if (isContainingPath(worktree.canonicalPath, normalizedCwd)) {
+      return worktree
+    }
+  }
+  return null
+}
+
+export async function attributeOpenCodeUsageEvent(
+  event: OpenCodeUsageParsedEvent,
+  worktrees: (OpenCodeUsageWorktreeRef & { canonicalPath: string })[]
+): Promise<OpenCodeUsageAttributedEvent | null> {
+  const day = localDayFromTimestamp(event.timestamp)
+  if (!day) {
+    return null
+  }
+
+  let repoId: string | null = null
+  let worktreeId: string | null = null
+  let projectKey = 'unscoped'
+  let projectLabel = getDefaultProjectLabel(event.cwd)
+
+  if (event.cwd) {
+    const worktree = findContainingWorktree(event.cwd, worktrees)
+    if (worktree) {
+      repoId = worktree.repoId
+      worktreeId = worktree.worktreeId
+      projectKey = `worktree:${worktree.worktreeId}`
+      projectLabel = worktree.displayName
+    } else {
+      projectKey = `cwd:${normalizeComparablePath(event.cwd)}`
+    }
+  }
+
+  return {
+    ...event,
+    day,
+    projectKey,
+    projectLabel,
+    repoId,
+    worktreeId
+  }
+}