Fix ESLint issues in core modules

- Add explicit null checks and type guards
- Use nullish coalescing (??) instead of logical OR (||)
- Fix floating promises with proper await/void handling
- Remove invalid generateObject options (mode, maxTokens)
- Add type annotations for parsed JSON values
- Use consistent type imports

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

src/core/codex-detector.ts

···
 import type { SessionFile } from '../types';
 
 /**
+ * New format (post-October 2025): session_meta type with nested payload
+ */
+interface NewFormatEntry {
+  type: string;
+  payload?: {
+    cwd?: string;
+    id?: string;
+    git?: {
+      branch?: string;
+    };
+  };
+}
+
+/**
+ * Old format (pre-October 2025): flat structure with id at top level
+ */
+interface OldFormatEntry {
+  id?: string;
+  type?: string;
+  git?: {
+    branch?: string;
+  };
+}
+
+/**
+ * Message entry in old format sessions
+ */
+interface OldFormatMessage {
+  type?: string;
+  content?: {
+    type?: string;
+    text?: string;
+  }[];
+}
+
+/**
  * Get Codex config directory if it exists
  */
 export function getCodexPaths(): string[] {
···
   try {
     const content = readFileSync(filePath, 'utf-8');
     const lines = content.split('\n');
-    const firstLine = lines[0];
-    if (!firstLine) return null;
+    const firstLine = lines[0] ?? '';
+    if (firstLine.length === 0) return null;
+
+    const entry = JSON.parse(firstLine) as unknown;
+
+    // Type guard for new format
+    const isNewFormat = (e: unknown): e is NewFormatEntry => {
+      return (
+        typeof e === 'object' &&
+        e !== null &&
+        'type' in e &&
+        typeof e.type === 'string' &&
+        e.type === 'session_meta'
+      );
+    };
 
-    const entry = JSON.parse(firstLine);
+    // Type guard for old format
+    const isOldFormat = (e: unknown): e is OldFormatEntry => {
+      return (
+        typeof e === 'object' &&
+        e !== null &&
+        'id' in e &&
+        typeof e.id === 'string' &&
+        e.id.length > 0 &&
+        (!('type' in e) || typeof e.type !== 'string' || e.type.length === 0)
+      );
+    };
 
     // New format: type === 'session_meta' with payload.cwd
-    if (entry.type === 'session_meta' && entry.payload?.cwd) {
-      return {
-        cwd: entry.payload.cwd,
-        sessionId: entry.payload.id || '',
-        gitBranch: entry.payload.git?.branch || '',
-      };
+    if (isNewFormat(entry)) {
+      const cwd = entry.payload?.cwd;
+      if (cwd !== undefined && cwd.length > 0) {
+        return {
+          cwd,
+          sessionId: entry.payload?.id ?? '',
+          gitBranch: entry.payload?.git?.branch ?? '',
+        };
+      }
     }
 
     // Old format: id at top level, cwd in environment_context message
-    if (entry.id && !entry.type) {
-      const sessionId = entry.id;
-      const gitBranch = entry.git?.branch || '';
+    if (isOldFormat(entry)) {
+      const sessionId = entry.id ?? '';
+      const gitBranch = entry.git?.branch ?? '';
 
       // Search first few lines for environment_context with cwd
       for (let i = 0; i < Math.min(lines.length, 10); i++) {
-        const line = lines[i];
-        if (!line) continue;
+        const line = lines[i] ?? '';
+        if (line.length === 0) continue;
         try {
-          const msg = JSON.parse(line);
-          if (msg.type === 'message' && msg.content) {
+          const msg = JSON.parse(line) as OldFormatMessage;
+          if (
+            msg.type === 'message' &&
+            msg.content !== undefined &&
+            Array.isArray(msg.content)
+          ) {
             for (const block of msg.content) {
-              if (block.type === 'input_text' && block.text?.includes('Current working directory:')) {
-                const match = block.text.match(/Current working directory: ([^\n\\]+)/);
-                if (match) {
-                  return { cwd: match[1], sessionId, gitBranch };
+              if (
+                block.type === 'input_text' &&
+                block.text?.includes('Current working directory:') === true
+              ) {
+                const cwdRegex = /Current working directory: ([^\n\\]+)/;
+                const match = cwdRegex.exec(block.text);
+                const extractedCwd = match?.[1];
+                if (extractedCwd !== undefined) {
+                  return { cwd: extractedCwd, sessionId, gitBranch };
                 }
               }
             }
           }
         } catch {
-          // Skip malformed lines
+          // ignore parse errors
         }
       }
     }
   } catch {
-    // Invalid JSON or missing fields
+    // ignore parse errors
   }
   return null;
 }
···
 function getProjectInfo(cwd: string): { projectPath: string; projectName: string } {
   // Try to find git root for canonical project identity
   const gitRoot = findGitRoot(cwd);
-  if (gitRoot) {
+  if (gitRoot !== null && gitRoot.length > 0) {
     return {
       projectPath: gitRoot,
-      projectName: gitRoot.split('/').pop() || 'unknown',
+      projectName: gitRoot.split('/').pop() ?? 'unknown',
     };
   }
 
   // Fallback to cwd itself
   return {
     projectPath: cwd,
-    projectName: cwd.split('/').pop() || 'unknown',
+    projectName: cwd.split('/').pop() ?? 'unknown',
   };
 }
 
···
 
             // Extract project info from session_meta
             const meta = extractCodexSessionMeta(filePath);
-            if (!meta?.cwd) continue;
+            if (meta === null || meta.cwd.length === 0) continue;
 
             const { projectPath, projectName } = getProjectInfo(meta.cwd);
 
···
               path: filePath,
               projectPath,
               projectName,
-              sessionId: meta.sessionId || file.replace('.jsonl', ''),
+              sessionId: meta.sessionId.length > 0 ? meta.sessionId : file.replace('.jsonl', ''),
               modifiedAt: fileStat.mtime,
               fileHash: '', // Computed lazily
               source: 'codex',

src/core/codex-reader.ts

···
 
 // Codex JSONL entry types
 interface CodexEntry {
-  timestamp: string;
+  timestamp?: string;
   type: 'session_meta' | 'event_msg' | 'response_item' | 'turn_context' | 'message' | 'function_call';
   payload: unknown;
 }
 
 interface CodexSessionMeta {
-  id: string;
-  cwd: string;
+  id?: string;
+  cwd?: string;
   cli_version?: string;
   model_provider?: string;
   git?: {
···
       reasoning_output_tokens?: number;
     };
   };
+}
+
+interface CodexContentItem {
+  type: string;
+  text?: string;
 }
 
 interface CodexResponseItem {
   type: 'message' | 'function_call' | 'function_call_output' | 'custom_tool_call' | 'reasoning';
   role?: string;
-  content?: Array<{ type: string; text?: string }>;
+  content?: CodexContentItem[];
   name?: string;
   input?: string; // For function_call/custom_tool_call (apply_patch content)
   arguments?: string; // For function_call (shell args as JSON)
···
 function extractFilesFromPatch(patchContent: string): string[] {
   const files: string[] = [];
   const regex = /\*\*\* (?:Add|Update|Delete) File:\s*(.+)/g;
-  let match;
-  while ((match = regex.exec(patchContent)) !== null) {
+  let match = regex.exec(patchContent);
+  while (match !== null) {
     const filePath = match[1].trim();
-    if (filePath && !files.includes(filePath)) {
+    if (filePath !== '' && !files.includes(filePath)) {
       files.push(filePath);
     }
+    match = regex.exec(patchContent);
   }
   return files;
 }
···
     apply_patch: 'Edit',
     update_plan: 'TodoWrite',
   };
-  return mapping[name] || name;
+  return mapping[name] ?? name;
+}
+
+interface ShellArgs {
+  command?: unknown;
 }
 
 /**
···
 function summarizeCodexToolInput(name: string, payload: CodexResponseItem): string {
   const MAX_LENGTH = 200;
 
-  if ((name === 'shell' || name === 'shell_command') && payload.arguments) {
+  if ((name === 'shell' || name === 'shell_command') && payload.arguments !== undefined) {
     try {
-      const args = JSON.parse(payload.arguments);
-      const cmd = Array.isArray(args.command) ? args.command.join(' ') : String(args.command || '');
+      const args = JSON.parse(payload.arguments) as ShellArgs;
+      let cmd = '';
+      if (Array.isArray(args.command)) {
+        cmd = args.command.join(' ');
+      } else if (typeof args.command === 'string' || typeof args.command === 'number' || typeof args.command === 'boolean') {
+        cmd = String(args.command);
+      }
       return truncate(cmd, MAX_LENGTH);
     } catch {
       return truncate(payload.arguments, MAX_LENGTH);
     }
   }
 
-  if (name === 'apply_patch' && payload.input) {
+  if (name === 'apply_patch' && payload.input !== undefined) {
     // Extract first file path from patch
     const files = extractFilesFromPatch(payload.input);
     if (files.length > 0) {
-      return files.length === 1 ? files[0] : `${files[0]} (+${files.length - 1} more)`;
+      const additionalFiles = files.length - 1;
+      return files.length === 1 ? files[0] : `${files[0]} (+${additionalFiles.toString()} more)`;
     }
     return truncate(payload.input, MAX_LENGTH);
   }
···
 /**
  * Extract text content from Codex message content array
  */
-function extractTextFromContent(content: Array<{ type: string; text?: string }> | undefined): string {
-  if (!content || !Array.isArray(content)) return '';
+function extractTextFromContent(content: CodexContentItem[] | undefined): string {
+  if (content === undefined || !Array.isArray(content)) return '';
   const texts: string[] = [];
   for (const item of content) {
     // Handle both new format ('text') and old format ('input_text', 'output_text')
-    if ((item.type === 'text' || item.type === 'input_text' || item.type === 'output_text') && item.text) {
+    if ((item.type === 'text' || item.type === 'input_text' || item.type === 'output_text') && item.text !== undefined) {
       texts.push(item.text);
     }
   }
···
 
   for await (const entry of parseCodexJSONLStream(filePath)) {
     // Track timestamps (skip entries without timestamps - common in old format)
-    if (entry.timestamp) {
-      if (!startTime || entry.timestamp < startTime) startTime = entry.timestamp;
-      if (!endTime || entry.timestamp > endTime) endTime = entry.timestamp;
+    if (entry.timestamp !== undefined && entry.timestamp !== '') {
+      if (startTime === '' || entry.timestamp < startTime) startTime = entry.timestamp;
+      if (endTime === '' || entry.timestamp > endTime) endTime = entry.timestamp;
     }
 
     // Handle session_meta (first line) - new format
     if (entry.type === 'session_meta') {
       const meta = entry.payload as CodexSessionMeta;
-      sessionId = meta.id || '';
-      gitBranch = meta.git?.branch || '';
+      sessionId = meta.id ?? '';
+      gitBranch = meta.git !== undefined ? meta.git.branch : '';
       continue;
     }
 
     // Handle old format first line (pre-October 2025): {id, timestamp, git, ...} without type
-    const rawEntry = entry as Record<string, unknown>;
-    if (rawEntry.id && !rawEntry.type && rawEntry.git) {
+    const rawEntry = entry as unknown as Record<string, unknown>;
+    if (rawEntry.id !== undefined && rawEntry.type === undefined && rawEntry.git !== undefined) {
       sessionId = rawEntry.id as string;
-      gitBranch = (rawEntry.git as Record<string, unknown>)?.branch as string || '';
+      const git = rawEntry.git as Record<string, unknown>;
+      gitBranch = (git.branch !== undefined ? git.branch as string : '');
       continue;
     }
 
···
         userMessages++;
         messages.push({
           type: 'user',
-          timestamp: entry.timestamp,
-          text: payload.message || '',
+          timestamp: entry.timestamp ?? '',
+          text: payload.message ?? '',
           toolUses: [],
         });
       } else if (payload.type === 'agent_message') {
         assistantMessages++;
         messages.push({
           type: 'assistant',
-          timestamp: entry.timestamp,
-          text: payload.message || '',
+          timestamp: entry.timestamp ?? '',
+          text: payload.message ?? '',
           toolUses: [],
         });
-      } else if (payload.type === 'token_count' && payload.info?.total_token_usage) {
+      } else if (payload.type === 'token_count' && payload.info?.total_token_usage !== undefined) {
         // Track final token counts (total_token_usage accumulates)
         const usage = payload.info.total_token_usage;
-        totalInputTokens = usage.input_tokens + (usage.cached_input_tokens || 0);
-        totalOutputTokens = usage.output_tokens + (usage.reasoning_output_tokens || 0);
+        totalInputTokens = usage.input_tokens + (usage.cached_input_tokens ?? 0);
+        totalOutputTokens = usage.output_tokens + (usage.reasoning_output_tokens ?? 0);
       }
       continue;
     }
···
       const payload = entry.payload as CodexResponseItem;
 
       // Function calls and custom tool calls (equivalent to Claude tool_use)
-      if ((payload.type === 'function_call' || payload.type === 'custom_tool_call') && payload.name) {
+      if ((payload.type === 'function_call' || payload.type === 'custom_tool_call') && payload.name !== undefined) {
         const mappedName = mapCodexToolName(payload.name);
-        toolCalls[mappedName] = (toolCalls[mappedName] || 0) + 1;
+        toolCalls[mappedName] = (toolCalls[mappedName] ?? 0) + 1;
 
         // Extract files from apply_patch
-        if (payload.name === 'apply_patch' && payload.input) {
+        if (payload.name === 'apply_patch' && payload.input !== undefined) {
           const files = extractFilesFromPatch(payload.input);
           files.forEach((f) => filesChanged.add(f));
         }
···
         assistantMessages++;
         messages.push({
           type: 'assistant',
-          timestamp: entry.timestamp,
+          timestamp: entry.timestamp ?? '',
           text: '',
           toolUses: [toolUse],
         });
       }
 
       // Agent text messages from response_item
-      if (payload.type === 'message' && payload.role === 'assistant' && payload.content) {
+      if (payload.type === 'message' && payload.role === 'assistant' && payload.content !== undefined) {
         const text = extractTextFromContent(payload.content);
-        if (text) {
+        if (text !== '') {
           assistantMessages++;
           messages.push({
             type: 'assistant',
-            timestamp: entry.timestamp,
+            timestamp: entry.timestamp ?? '',
             text,
             toolUses: [],
           });
···
 
     // Handle old format: top-level function_call (pre-October 2025)
     // Old format: {"type":"function_call","name":"shell","arguments":"{\"command\":[\"bash\",\"-lc\",\"apply_patch...\"]}"}
-    if (entry.type === 'function_call' && (entry as Record<string, unknown>).name) {
-      const oldEntry = entry as Record<string, unknown>;
+    if (entry.type === 'function_call' && (entry as unknown as Record<string, unknown>).name !== undefined) {
+      const oldEntry = entry as unknown as Record<string, unknown>;
       const name = oldEntry.name as string;
-      const argsStr = oldEntry.arguments as string;
+      const argsStr = oldEntry.arguments as string | undefined;
 
       // Check if this is a shell command containing apply_patch
-      if (name === 'shell' && argsStr) {
+      if (name === 'shell' && argsStr !== undefined) {
         try {
-          const args = JSON.parse(argsStr);
+          const args = JSON.parse(argsStr) as ShellArgs;
           const command = args.command;
           if (Array.isArray(command) && command.length >= 3) {
             const shellCmd = command[2] as string;
-            if (shellCmd?.includes('apply_patch')) {
+            const patchRegex = /apply_patch\s*<<\s*['"]?PATCH['"]?\n([\s\S]*?)\n\s*PATCH/;
+            const patchMatch = patchRegex.exec(shellCmd);
+            if (shellCmd.includes('apply_patch') && patchMatch !== null) {
               // Extract the patch content from the heredoc
-              const patchMatch = shellCmd.match(/apply_patch\s*<<\s*['"]?PATCH['"]?\n([\s\S]*?)\n\s*PATCH/);
-              if (patchMatch) {
-                toolCalls['Edit'] = (toolCalls['Edit'] || 0) + 1;
-                const files = extractFilesFromPatch(patchMatch[1]);
-                files.forEach((f) => filesChanged.add(f));
+              toolCalls.Edit = ('Edit' in toolCalls ? toolCalls.Edit : 0) + 1;
+              const files = extractFilesFromPatch(patchMatch[1]);
+              files.forEach((f) => filesChanged.add(f));
 
-                assistantMessages++;
-                messages.push({
-                  type: 'assistant',
-                  timestamp: (oldEntry.timestamp as string) || '',
-                  text: '',
-                  toolUses: [{
-                    name: 'Edit',
-                    input: `apply_patch: ${files.join(', ') || 'file changes'}`,
-                    rawInput: oldEntry,
-                  }],
-                });
-              }
+              assistantMessages++;
+              messages.push({
+                type: 'assistant',
+                timestamp: (oldEntry.timestamp as string | undefined) ?? '',
+                text: '',
+                toolUses: [{
+                  name: 'Edit',
+                  input: `apply_patch: ${files.join(', ') !== '' ? files.join(', ') : 'file changes'}`,
+                  rawInput: oldEntry,
+                }],
+              });
             } else {
               // Regular shell command
-              toolCalls['Bash'] = (toolCalls['Bash'] || 0) + 1;
+              toolCalls.Bash = ('Bash' in toolCalls ? toolCalls.Bash : 0) + 1;
               assistantMessages++;
               messages.push({
                 type: 'assistant',
-                timestamp: (oldEntry.timestamp as string) || '',
+                timestamp: (oldEntry.timestamp as string | undefined) ?? '',
                 text: '',
                 toolUses: [{
                   name: 'Bash',
-                  input: shellCmd?.substring(0, 100) || 'shell command',
+                  input: shellCmd.substring(0, 100),
                   rawInput: oldEntry,
                 }],
               });
···
     // Handle old format: top-level message (pre-October 2025)
     // Old format: {"type":"message","role":"user/assistant","content":[{"type":"input_text/output_text","text":"..."}]}
     if (entry.type === 'message') {
-      const msgEntry = entry as unknown as { type: string; role: string; content?: Array<{ type: string; text?: string }> };
+      const msgEntry = entry as unknown as { type: string; role: string; content?: CodexContentItem[]; timestamp?: string };
       const text = extractTextFromContent(msgEntry.content);
 
       // Skip environment_context messages (just contain cwd/approval policy info)
-      if (text && !text.includes('<environment_context>')) {
+      if (text !== '' && !text.includes('<environment_context>')) {
         if (msgEntry.role === 'user') {
           userMessages++;
           messages.push({
             type: 'user',
-            timestamp: (entry as Record<string, unknown>).timestamp as string || '',
+            timestamp: msgEntry.timestamp ?? '',
             text,
             toolUses: [],
           });
···
           assistantMessages++;
           messages.push({
             type: 'assistant',
-            timestamp: (entry as Record<string, unknown>).timestamp as string || '',
+            timestamp: msgEntry.timestamp ?? '',
             text,
             toolUses: [],
           });
···
   }
 
   // Fallback to filename for sessionId
-  if (!sessionId) {
-    sessionId = filePath.split('/').pop()?.replace('.jsonl', '') || 'unknown';
+  if (sessionId === '') {
+    const filename = filePath.split('/').pop();
+    sessionId = filename?.replace('.jsonl', '') ?? 'unknown';
   }
 
   // Provide default timestamps if none found
   const now = new Date().toISOString();
-  if (!startTime) startTime = now;
-  if (!endTime) endTime = startTime;
+  if (startTime === '') startTime = now;
+  if (endTime === '') endTime = startTime;
 
   // Derive date from endTime with 3am boundary
   const date = getEffectiveDate(endTime);

src/core/db.ts

···
 import { Database } from 'bun:sqlite';
-import { join, dirname } from 'path';
+import { join } from 'path';
 import { mkdirSync, existsSync } from 'fs';
 import type {
   DBSessionSummary,
   DBDailySummary,
   DBProcessedFile,
-  DBProject,
   SessionSummary,
   ParsedSession,
   SessionStats,
···
 }
 
 function initSchema() {
-  const database = db!;
+  const database = db;
+  if (!database) {
+    throw new Error('Database not initialized');
+  }
 
-  database.exec(`
+  database.run(`
     CREATE TABLE IF NOT EXISTS session_summaries (
       id INTEGER PRIMARY KEY,
       session_id TEXT UNIQUE NOT NULL,
···
  * Run database migrations
  */
 function runMigrations(): void {
-  const database = db!;
+  const database = db;
+  if (!database) {
+    throw new Error('Database not initialized');
+  }
 
   // Check if source column exists
   const columns = database
···
 
   if (!hasSourceColumn) {
     console.log('Migration: Adding source column to session_summaries...');
-    database.exec(`
+    database.run(`
       ALTER TABLE session_summaries ADD COLUMN source TEXT DEFAULT 'claude';
     `);
     console.log('Migration complete.');
···
   let totalTokens = 0;
 
   for (const session of sessions) {
-    const stats: SessionStats = JSON.parse(session.stats || '{}');
-    totalTokens += (stats.totalInputTokens || 0) + (stats.totalOutputTokens || 0);
+    const stats = JSON.parse(session.stats ?? '{}') as SessionStats;
+    totalTokens += (stats.totalInputTokens ?? 0) + (stats.totalOutputTokens ?? 0);
 
     const sessionDetail: SessionDetail = {
       sessionId: session.session_id,
       startTime: session.start_time,
       endTime: session.end_time,
-      shortSummary: session.short_summary,
-      accomplishments: JSON.parse(session.accomplishments || '[]'),
-      filesChanged: JSON.parse(session.files_changed || '[]'),
-      toolsUsed: JSON.parse(session.tools_used || '[]'),
+      shortSummary: session.short_summary ?? '',
+      accomplishments: JSON.parse(session.accomplishments ?? '[]') as string[],
+      filesChanged: JSON.parse(session.files_changed ?? '[]') as string[],
+      toolsUsed: JSON.parse(session.tools_used ?? '[]') as string[],
       stats,
     };
 
-    const existing = projectMap.get(session.project_path) || [];
+    const existing = projectMap.get(session.project_path) ?? [];
     existing.push(sessionDetail);
     projectMap.set(session.project_path, existing);
   }
 
   const projects: ProjectDetail[] = Array.from(projectMap.entries()).map(
     ([path, sessions]) => ({
-      name: sessions[0]?.sessionId ? path.split('/').pop() || path : path,
+      name: sessions[0]?.sessionId ? path.split('/').pop() ?? path : path,
       path,
       sessions,
     })
···
   // Get project name from first session
   for (const project of projects) {
     const firstSession = sessions.find((s) => s.project_path === project.path);
-    if (firstSession?.project_name) {
+    if (firstSession !== undefined && firstSession.project_name !== null && firstSession.project_name !== '') {
       project.name = firstSession.project_name;
     }
   }
···
   `).get();
 
   return {
-    totalSessions: stats?.total_sessions || 0,
-    totalDays: stats?.total_days || 0,
-    totalProjects: stats?.total_projects || 0,
+    totalSessions: stats?.total_sessions ?? 0,
+    totalDays: stats?.total_days ?? 0,
+    totalProjects: stats?.total_projects ?? 0,
   };
 }
 
···
     'SELECT COUNT(*) as count FROM session_summaries WHERE project_path = ? AND date < ?'
   ).get(projectPath, beforeDate);
 
-  return (row?.count || 0) === 0;
+  return (row?.count ?? 0) === 0;
 }
 
 /**
···
  * Backfill projects table from existing session data (one-time migration)
  */
 function backfillProjectsIfNeeded(): void {
-  const database = db!;
+  const database = db;
+  if (!database) {
+    throw new Error('Database not initialized');
+  }
 
   // Check if projects table is empty but sessions exist
   const projectCount =
     database
       .query<{ count: number }, []>('SELECT COUNT(*) as count FROM projects')
-      .get()?.count || 0;
+      .get()?.count ?? 0;
 
   const sessionCount =
     database
       .query<{ count: number }, []>(
         'SELECT COUNT(*) as count FROM session_summaries'
       )
-      .get()?.count || 0;
+      .get()?.count ?? 0;
 
   if (projectCount === 0 && sessionCount > 0) {
     console.log('Backfilling projects table from session data...');
···
     const filled =
       database
         .query<{ count: number }, []>('SELECT COUNT(*) as count FROM projects')
-        .get()?.count || 0;
-    console.log(`Created ${filled} project records.`);
+        .get()?.count ?? 0;
+    console.log(`Created ${String(filled)} project records.`);
   }
 }
 
···
         first_session_date: string;
         last_session_date: string;
         total_sessions: number;
-        days_since_last: number;
+        days_since_last: number | null;
       },
       string[]
     >(query)
···
     firstSessionDate: row.first_session_date,
     lastSessionDate: row.last_session_date,
     totalSessions: row.total_sessions,
-    daysSinceLastSession: row.days_since_last || 0,
+    daysSinceLastSession: row.days_since_last ?? 0,
   }));
 }
 

src/core/session-detector.ts

···
   }
 
   // Filesystem probing failed - try reading cwd from session file
-  if (sessionFilePath && existsSync(sessionFilePath)) {
+  if (sessionFilePath !== undefined && existsSync(sessionFilePath)) {
     const cwd = extractCwdFromSessionFile(sessionFilePath);
-    if (cwd) {
+    if (cwd !== null) {
       return cwd;
     }
   }
···
     for (const line of lines) {
       if (!line.trim()) continue;
       try {
-        const entry = JSON.parse(line);
-        if (entry.cwd && typeof entry.cwd === 'string') {
+        const entry: unknown = JSON.parse(line);
+        if (
+          typeof entry === 'object' &&
+          entry !== null &&
+          'cwd' in entry &&
+          typeof entry.cwd === 'string'
+        ) {
           return entry.cwd;
         }
-      } catch {}
+      } catch {
+        // Ignore malformed JSON lines
+      }
     }
-  } catch {}
+  } catch {
+    // Ignore file read errors
+  }
   return null;
 }
 
···
   const withoutLeading = folderName.slice(1);
 
   // Find the src/a/ or src/tries/ marker
-  const srcAMatch = withoutLeading.match(/^(Users-[^-]+-src-a)-(.+)$/);
-  const srcTriesMatch = withoutLeading.match(/^(Users-[^-]+-src-tries)-(.+)$/);
+  const srcAMatch = /^(Users-[^-]+-src-a)-(.+)$/.exec(withoutLeading);
+  const srcTriesMatch = /^(Users-[^-]+-src-tries)-(.+)$/.exec(withoutLeading);
 
   let decodedPath: string;
   let isTriesProject = false;
···
   // Try to find git root to normalize monorepo subdirectories
   if (existsSync(decodedPath)) {
     const gitRoot = findGitRoot(decodedPath);
-    if (gitRoot) {
-      let projectName = gitRoot.split('/').pop() || 'unknown';
+    if (gitRoot !== null) {
+      let projectName = gitRoot.split('/').pop() ?? 'unknown';
       // Strip date prefix from tries projects
       if (isTriesProject) {
         projectName = stripDatePrefix(projectName);
···
   }
 
   // No git root found - use the decoded path as-is
-  let projectName = decodedPath.split('/').pop() || 'unknown';
+  let projectName = decodedPath.split('/').pop() ?? 'unknown';
   // Strip date prefix from tries projects
   if (isTriesProject) {
     projectName = stripDatePrefix(projectName);
···
  * @deprecated Use decodeProjectFolder instead
  */
 export function getProjectName(projectPath: string): string {
-  return projectPath.split('/').filter(Boolean).pop() || 'unknown';
+  return projectPath.split('/').filter(Boolean).pop() ?? 'unknown';
 }
 
 /**
  * Calculate MD5 hash of a file
  */
-export function getFileHash(filePath: string): string {
-  const content = Bun.file(filePath).toString();
+export async function getFileHash(filePath: string): Promise<string> {
+  const file = Bun.file(filePath);
+  const content = await file.text();
   return createHash('md5').update(content).digest('hex');
 }
 
···
  */
 export function filterSessionsByDate(
   sessions: SessionFile[],
-  targetDate: string
+  _targetDate: string
 ): SessionFile[] {
   // We need to peek into files to check dates, but that's expensive
   // For now, return all and let the processor filter

src/core/session-reader.ts

···
   });
 
   for await (const line of rl) {
-    if (!line.trim()) continue;
+    if (line.trim() === '') continue;
     try {
       yield JSON.parse(line) as RawSessionEntry;
     } catch {
···
     seen.add(entry.uuid);
 
     // Extract metadata from first entry
-    if (!sessionId && entry.sessionId) {
+    if (sessionId === '') {
       sessionId = entry.sessionId;
     }
-    if (!gitBranch && entry.gitBranch) {
+    if (gitBranch === '' && entry.gitBranch !== undefined) {
       gitBranch = entry.gitBranch;
     }
 
     // Track timestamps
-    if (!startTime || entry.timestamp < startTime) {
+    if (startTime === '' || entry.timestamp < startTime) {
       startTime = entry.timestamp;
     }
-    if (!endTime || entry.timestamp > endTime) {
+    if (endTime === '' || entry.timestamp > endTime) {
       endTime = entry.timestamp;
     }
 
     // Extract token usage from assistant messages
-    if (entry.type === 'assistant' && entry.message?.usage) {
+    if (entry.type === 'assistant' && entry.message.usage !== undefined) {
       const usage = entry.message.usage;
-      totalInputTokens += usage.input_tokens || 0;
-      totalOutputTokens += usage.output_tokens || 0;
-      totalInputTokens += usage.cache_creation_input_tokens || 0;
-      totalInputTokens += usage.cache_read_input_tokens || 0;
+      totalInputTokens += usage.input_tokens;
+      totalOutputTokens += usage.output_tokens;
+      totalInputTokens += usage.cache_creation_input_tokens ?? 0;
+      totalInputTokens += usage.cache_read_input_tokens ?? 0;
     }
 
     // Parse message content
-    const text = extractText(entry.message?.content);
-    const toolUses = extractToolUses(entry.message?.content);
+    const text = extractText(entry.message.content);
+    const toolUses = extractToolUses(entry.message.content);
 
     // Count tool calls
     for (const tool of toolUses) {
-      toolCalls[tool.name] = (toolCalls[tool.name] || 0) + 1;
+      toolCalls[tool.name] = (toolCalls[tool.name] ?? 0) + 1;
     }
 
     if (entry.type === 'user') userMessages++;
···
   }
 
   // Use filename as sessionId fallback
-  if (!sessionId) {
-    sessionId = filePath.split('/').pop()?.replace('.jsonl', '') || 'unknown';
+  if (sessionId === '') {
+    sessionId = filePath.split('/').pop()?.replace('.jsonl', '') ?? 'unknown';
   }
 
   // Provide default timestamps if none found
   const now = new Date().toISOString();
-  if (!startTime) {
+  if (startTime === '') {
     startTime = now;
   }
-  if (!endTime) {
+  if (endTime === '') {
     endTime = startTime;
   }
 
···
 /**
  * Extract text from message content array
  */
-function extractText(content: MessageContent[] | undefined): string {
-  if (!content || !Array.isArray(content)) return '';
+function extractText(content: MessageContent[]): string {
+  if (!Array.isArray(content)) return '';
 
   const texts: string[] = [];
   for (const item of content) {
     if (item.type === 'text') {
       // Handle both formats: { text: "..." } and { content: "..." }
       const text = 'text' in item ? item.text : 'content' in item ? item.content : '';
-      if (text) texts.push(text);
+      if (text !== '') texts.push(text);
     }
   }
   return texts.join('\n');
···
 /**
  * Extract tool uses from message content
  */
-function extractToolUses(content: MessageContent[] | undefined): ToolUse[] {
-  if (!content || !Array.isArray(content)) return [];
+function extractToolUses(content: MessageContent[]): ToolUse[] {
+  if (!Array.isArray(content)) return [];
 
   const tools: ToolUse[] = [];
   for (const item of content) {
···
 
   switch (toolName) {
     case 'Bash':
-      return truncate(String(input.command || ''), MAX_LENGTH);
+      return truncate(typeof input.command === 'string' ? input.command : '', MAX_LENGTH);
     case 'Read':
-      return truncate(String(input.file_path || ''), MAX_LENGTH);
+      return truncate(typeof input.file_path === 'string' ? input.file_path : '', MAX_LENGTH);
     case 'Write':
     case 'Edit':
-      return truncate(String(input.file_path || ''), MAX_LENGTH);
+      return truncate(typeof input.file_path === 'string' ? input.file_path : '', MAX_LENGTH);
     case 'Glob':
-      return truncate(String(input.pattern || ''), MAX_LENGTH);
+      return truncate(typeof input.pattern === 'string' ? input.pattern : '', MAX_LENGTH);
     case 'Grep':
-      return truncate(String(input.pattern || ''), MAX_LENGTH);
+      return truncate(typeof input.pattern === 'string' ? input.pattern : '', MAX_LENGTH);
     case 'Task':
-      return truncate(String(input.description || ''), MAX_LENGTH);
+      return truncate(typeof input.description === 'string' ? input.description : '', MAX_LENGTH);
     default:
       return truncate(JSON.stringify(input), MAX_LENGTH);
   }
···
 
   for (const file of files) {
     const lower = file.toLowerCase();
-    const filename = file.split('/').pop() || '';
+    const filename = file.split('/').pop() ?? '';
 
     // Tests
     if (
···
   const threshold = total * 0.5;
 
   if (scope.tests > threshold) {
-    signals.push(`${scope.tests}/${total} files are tests`);
+    signals.push(`${scope.tests.toString()}/${total.toString()} files are tests`);
     return { type: 'tests', signals, scope, scopeSummary };
   }
 
   if (scope.docs > threshold) {
-    signals.push(`${scope.docs}/${total} files are documentation`);
+    signals.push(`${scope.docs.toString()}/${total.toString()} files are documentation`);
     return { type: 'docs', signals, scope, scopeSummary };
   }
 
   if (scope.types + scope.config > threshold) {
     if (scope.types > scope.config) {
-      signals.push(`${scope.types}/${total} files are types`);
+      signals.push(`${scope.types.toString()}/${total.toString()} files are types`);
     } else {
-      signals.push(`${scope.config}/${total} files are config`);
+      signals.push(`${scope.config.toString()}/${total.toString()} files are config`);
     }
     return { type: 'infrastructure', signals, scope, scopeSummary };
   }
 
   if (featureFiles > threshold) {
-    signals.push(`${featureFiles}/${total} files are feature code`);
+    signals.push(`${featureFiles.toString()}/${total.toString()} files are feature code`);
     return { type: 'feature', signals, scope, scopeSummary };
   }
 
   // Mixed - build a description
-  if (featureFiles > 0) signals.push(`${featureFiles} feature`);
-  if (scope.tests > 0) signals.push(`${scope.tests} test`);
-  if (scope.types > 0) signals.push(`${scope.types} type`);
-  if (scope.config > 0) signals.push(`${scope.config} config`);
-  if (scope.docs > 0) signals.push(`${scope.docs} doc`);
+  if (featureFiles > 0) signals.push(`${featureFiles.toString()} feature`);
+  if (scope.tests > 0) signals.push(`${scope.tests.toString()} test`);
+  if (scope.types > 0) signals.push(`${scope.types.toString()} type`);
+  if (scope.config > 0) signals.push(`${scope.config.toString()} config`);
+  if (scope.docs > 0) signals.push(`${scope.docs.toString()} doc`);
 
   return { type: 'mixed', signals, scope, scopeSummary };
 }
···
   const parts: string[] = [];
 
   parts.push(`Project: ${session.projectName}`);
-  if (session.gitBranch) {
+  if (session.gitBranch !== '') {
     parts.push(`Branch: ${session.gitBranch}`);
   }
   parts.push(`Duration: ${formatDuration(session.startTime, session.endTime)}`);
···
     if (msg.type === 'assistant') {
       for (const tool of msg.toolUses) {
         if (tool.name === 'Write') {
-          const path = String((tool.rawInput as any)?.file_path || '');
-          if (path && !filesWritten.includes(path)) {
+          const rawInput = tool.rawInput;
+          const filePath = rawInput?.file_path;
+          const path = typeof filePath === 'string' ? filePath : '';
+          if (path !== '' && !filesWritten.includes(path)) {
             filesWritten.push(path);
           }
         } else if (tool.name === 'Edit') {
-          const path = String((tool.rawInput as any)?.file_path || '');
-          if (path && !filesEdited.includes(path)) {
+          const rawInput = tool.rawInput;
+          const filePath = rawInput?.file_path;
+          const path = typeof filePath === 'string' ? filePath : '';
+          if (path !== '' && !filesEdited.includes(path)) {
             filesEdited.push(path);
           }
         } else if (tool.name === 'Bash') {
-          const cmd = String((tool.rawInput as any)?.command || '').slice(0, 100);
-          if (cmd && commandsRun.length < 10) {
+          const rawInput = tool.rawInput;
+          const command = rawInput?.command;
+          const cmd = typeof command === 'string' ? command.slice(0, 100) : '';
+          if (cmd !== '' && commandsRun.length < 10) {
             commandsRun.push(cmd);
           }
         }
···
   const allFiles = [...filesWritten, ...filesEdited];
   const classification = classifyWork(allFiles);
   parts.push(`WORK TYPE: ${classification.type}`);
-  if (classification.scopeSummary) {
+  if (classification.scopeSummary !== '') {
     parts.push(`SCOPE: ${classification.scopeSummary}`);
   }
   parts.push('');
 
   // Show action summary at the TOP
   if (filesWritten.length > 0) {
-    parts.push(`FILES CREATED (${filesWritten.length}):`);
+    parts.push(`FILES CREATED (${filesWritten.length.toString()}):`);
     filesWritten.slice(0, 15).forEach(f => parts.push(`  - ${f}`));
-    if (filesWritten.length > 15) parts.push(`  ... and ${filesWritten.length - 15} more`);
+    if (filesWritten.length > 15) parts.push(`  ... and ${(filesWritten.length - 15).toString()} more`);
     parts.push('');
   }
 
   if (filesEdited.length > 0) {
-    parts.push(`FILES EDITED (${filesEdited.length}):`);
+    parts.push(`FILES EDITED (${filesEdited.length.toString()}):`);
     filesEdited.slice(0, 15).forEach(f => parts.push(`  - ${f}`));
-    if (filesEdited.length > 15) parts.push(`  ... and ${filesEdited.length - 15} more`);
+    if (filesEdited.length > 15) parts.push(`  ... and ${(filesEdited.length - 15).toString()} more`);
     parts.push('');
   }
 
   if (commandsRun.length > 0) {
-    parts.push(`COMMANDS RUN (${commandsRun.length}):`);
+    parts.push(`COMMANDS RUN (${commandsRun.length.toString()}):`);
     commandsRun.slice(0, 5).forEach(c => parts.push(`  $ ${c}`));
     parts.push('');
   }
···
   for (const msg of session.messages) {
     if (messageCount > 20) break; // Limit to avoid overwhelming
 
-    if (msg.type === 'user' && msg.text) {
+    if (msg.type === 'user' && msg.text !== '') {
       const text = msg.text.slice(0, 300);
       parts.push(`User: ${text}`);
       messageCount++;
-    } else if (msg.type === 'assistant' && msg.text) {
+    } else if (msg.type === 'assistant' && msg.text !== '') {
       const text = msg.text.slice(0, 200);
       parts.push(`Assistant: ${text}`);
       messageCount++;
···
   const toolSummary = Object.entries(session.stats.toolCalls)
     .sort((a, b) => b[1] - a[1])
     .slice(0, 10)
-    .map(([name, count]) => `${name}(${count})`)
+    .map(([name, count]) => `${name}(${count.toString()})`)
     .join(', ');
-  if (toolSummary) {
+  if (toolSummary !== '') {
     parts.push(`Tool usage: ${toolSummary}`);
   }
 
···
 }
 
 function formatDuration(start: string, end: string): string {
-  if (!start || !end) return 'unknown';
+  if (start === '' || end === '') return 'unknown';
 
   const startDate = new Date(start);
   const endDate = new Date(end);
   const diffMs = endDate.getTime() - startDate.getTime();
 
   const minutes = Math.floor(diffMs / 60000);
-  if (minutes < 60) return `${minutes} min`;
+  if (minutes < 60) return `${minutes.toString()} min`;
 
   const hours = Math.floor(minutes / 60);
   const remainingMinutes = minutes % 60;
-  return `${hours}h ${remainingMinutes}m`;
+  return `${hours.toString()}h ${remainingMinutes.toString()}m`;
 }

src/core/summarizer.ts

···
 import { createAnthropic } from '@ai-sdk/anthropic';
-import { generateObject, generateText } from 'ai';
+import { generateObject } from 'ai';
 import { z } from 'zod';
 import type { ParsedSession, SessionSummary, DBSessionSummary } from '../types';
 import { createCondensedTranscript } from './session-reader';
 
 const anthropic = createAnthropic({
   apiKey: process.env.WORKLOG_API_KEY,
-  ...(process.env.WORKLOG_BASE_URL && { baseURL: process.env.WORKLOG_BASE_URL }),
+  ...(process.env.WORKLOG_BASE_URL !== undefined && process.env.WORKLOG_BASE_URL.length > 0 && { baseURL: process.env.WORKLOG_BASE_URL }),
   headers: {
     'Accept-Encoding': 'identity',
   },
 });
 
-const MODEL = process.env.SUMMARIZER_MODEL || 'claude-haiku-4-5-20251001';
+const MODEL = process.env.SUMMARIZER_MODEL ?? 'claude-haiku-4-5-20251001';
 
 /**
  * Try to recover valid JSON from malformed Haiku responses.
···
     let rawText = errorObj.text;
 
     // Also try cause.value which contains the parsed (but invalid) object
-    if (!rawText && errorObj.cause?.value) {
+    if (rawText === undefined && errorObj.cause?.value !== undefined) {
       const value = errorObj.cause.value as { shortSummary?: string };
       // If shortSummary contains escaped JSON structure, extract it
-      if (value.shortSummary && value.shortSummary.includes('"accomplishments"')) {
+      if (value.shortSummary?.includes('"accomplishments"') === true) {
         rawText = value.shortSummary;
       }
     }
 
-    if (!rawText || typeof rawText !== 'string') return null;
+    if (rawText === undefined || typeof rawText !== 'string') return null;
 
     // Unescape the content
     const unescaped = rawText
···
 
     // Pattern: the model returned JSON with shortSummary containing the rest
     // Extract: shortSummary ends at ",\n"accomplishments" or similar
-    const summaryMatch = unescaped.match(/"shortSummary"\s*:\s*"([^"]+)"/);
-    const accomplishmentsMatch = unescaped.match(/"accomplishments"\s*:\s*\[([\s\S]*?)\]/);
-    const filesMatch = unescaped.match(/"filesChanged"\s*:\s*\[([\s\S]*?)\]/);
-    const toolsMatch = unescaped.match(/"toolsUsed"\s*:\s*\[([\s\S]*?)\]/);
+    const summaryMatch = /"shortSummary"\s*:\s*"([^"]+)"/.exec(unescaped);
+    const accomplishmentsMatch = /"accomplishments"\s*:\s*\[([\s\S]*?)\]/.exec(unescaped);
+    const filesMatch = /"filesChanged"\s*:\s*\[([\s\S]*?)\]/.exec(unescaped);
+    const toolsMatch = /"toolsUsed"\s*:\s*\[([\s\S]*?)\]/.exec(unescaped);
 
-    if (summaryMatch) {
+    if (summaryMatch !== null) {
       const parseArray = (match: RegExpMatchArray | null): string[] => {
-        if (!match) return [];
+        if (match === null) return [];
         try {
-          return JSON.parse(`[${match[1]}]`);
+          const parsed: unknown = JSON.parse(`[${match[1]}]`);
+          if (Array.isArray(parsed)) {
+            return parsed.filter((item): item is string => typeof item === 'string');
+          }
+          return [];
         } catch {
           // Extract strings manually
           const items: string[] = [];
···
 
     // Last resort: try to parse as complete JSON object
     try {
-      const jsonMatch = unescaped.match(/\{[\s\S]*"shortSummary"[\s\S]*\}/);
-      if (jsonMatch) {
-        const parsed = JSON.parse(jsonMatch[0]);
-        if (parsed.shortSummary && Array.isArray(parsed.accomplishments)) {
-          return parsed;
+      const jsonMatch = /\{[\s\S]*"shortSummary"[\s\S]*\}/.exec(unescaped);
+      if (jsonMatch !== null) {
+        const parsed: unknown = JSON.parse(jsonMatch[0]);
+        if (
+          typeof parsed === 'object' &&
+          parsed !== null &&
+          'shortSummary' in parsed &&
+          'accomplishments' in parsed &&
+          typeof parsed.shortSummary === 'string' &&
+          Array.isArray(parsed.accomplishments)
+        ) {
+          return parsed as {
+            shortSummary: string;
+            accomplishments: string[];
+            filesChanged?: string[];
+            toolsUsed?: string[];
+          };
         }
       }
-    } catch {}
+    } catch {
+      // Failed to parse as complete JSON, continue to outer catch
+    }
   } catch {
     // Recovery failed, will fall back to placeholder
   }
···
       schema: sessionSummarySchema,
       system: systemPrompt,
       prompt: userPrompt,
-      maxTokens: 1024,
-      mode: 'tool', // Force tool use mode for reliable structured output
     });
 
     return {
-      shortSummary: object.shortSummary || 'Session completed',
-      accomplishments: object.accomplishments || [],
-      filesChanged: object.filesChanged || [],
+      shortSummary: object.shortSummary,
+      accomplishments: object.accomplishments,
+      filesChanged: object.filesChanged,
       toolsUsed: object.toolsUsed.length > 0
         ? object.toolsUsed
         : Object.keys(session.stats.toolCalls),
···
     // Haiku sometimes returns double-encoded JSON (valid JSON wrapped in a string)
     // Try to recover by parsing the text field from the error
     const recovered = tryRecoverMalformedResponse(error);
-    if (recovered) {
+    if (recovered !== null) {
       return {
-        shortSummary: recovered.shortSummary || 'Session completed',
-        accomplishments: recovered.accomplishments || [],
-        filesChanged: recovered.filesChanged || [],
-        toolsUsed: recovered.toolsUsed?.length > 0
-          ? recovered.toolsUsed
+        shortSummary: recovered.shortSummary ?? 'Session completed',
+        accomplishments: recovered.accomplishments ?? [],
+        filesChanged: recovered.filesChanged ?? [],
+        toolsUsed: (recovered.toolsUsed?.length ?? 0) > 0
+          ? recovered.toolsUsed ?? []
           : Object.keys(session.stats.toolCalls),
       };
     }
···
 
 // Extended schema with isNew flag (added post-LLM)
 interface DailySummaryWithNew {
-  projects: Array<{
+  projects: {
     name: string;
     summary: string;
     isNew?: boolean;
-  }>;
+  }[];
 }
 
 export type DailySummary = z.infer<typeof dailySummarySchema>;
···
 export async function generateDailyBragSummary(
   date: string,
   sessions: DBSessionSummary[],
-  newProjectNames: Set<string> = new Set()
+  newProjectNames = new Set<string>()
 ): Promise<string> {
   if (sessions.length === 0) {
     return JSON.stringify({ projects: [] });
···
   // Group accomplishments by project
   const accomplishmentsByProject = new Map<string, string[]>();
   for (const session of sessions) {
-    const project = session.project_name;
+    const project = session.project_name ?? 'Unknown';
     if (!accomplishmentsByProject.has(project)) {
       accomplishmentsByProject.set(project, []);
     }
-    try {
-      const acc = JSON.parse(session.accomplishments || '[]');
-      accomplishmentsByProject.get(project)!.push(...acc);
-    } catch {}
+    if (session.accomplishments !== null) {
+      try {
+        const parsed: unknown = JSON.parse(session.accomplishments);
+        if (Array.isArray(parsed)) {
+          const stringItems = parsed.filter((item): item is string => typeof item === 'string');
+          const existing = accomplishmentsByProject.get(project);
+          if (existing !== undefined) {
+            existing.push(...stringItems);
+          }
+        }
+      } catch {
+        // Failed to parse accomplishments, skip this session
+      }
+    }
   }
 
   const projectSummaries = Array.from(accomplishmentsByProject.entries())
···
       schema: dailySummarySchema,
       system: systemPrompt,
       prompt: userPrompt,
-      maxTokens: 512,
-      mode: 'tool', // Force tool use mode for reliable structured output
     });
 
     // Add isNew flag to projects that are first-time appearances
···
     const result: DailySummaryWithNew = {
       projects: object.projects.map((p) => ({
         ...p,
-        isNew: isNewProject(p.name) || undefined,
+        isNew: isNewProject(p.name) ? true : undefined,
       })),
     };
 
···
     const projects = Array.from(accomplishmentsByProject.keys()).map(name => ({
       name,
       summary: 'Session details unavailable',
-      isNew: newProjectNames.has(name) || undefined,
+      isNew: newProjectNames.has(name) ? true : undefined,
     }));
     return JSON.stringify({ projects });
   }