/**
 * Session analyzer — TypeScript port of scripts/analyze-session.py.
 *
 * Takes a SessionDetail (already parsed by the main process) and produces
 * a SessionReport with structured metrics, cost analysis, friction signals,
 * conversation tree analysis, idle gap detection, and more.
 *
 * Runs entirely in the renderer process — no IPC needed.
 */

import {
  computeCacheEfficiencyAssessment,
  computeCacheRatioAssessment,
  computeCostPerCommitAssessment,
  computeCostPerLineAssessment,
  computeIdleAssessment,
  computeOverheadAssessment,
  computeRedundancyAssessment,
  computeSubagentCostShareAssessment,
  computeThrashingAssessment,
  computeToolHealthAssessment,
  detectModelMismatch,
  detectSwitchPattern,
} from '@renderer/utils/reportAssessments';
import { calculateMessageCost } from '@shared/utils/pricing';

import type {
  AgentTreeNode,
  FrictionCorrection,
  GitCommit,
  IdleGap,
  KeyEvent,
  ModelSwitch,
  ModelTokenStats,
  OutOfScopeFindings,
  SessionReport,
  SkillInvocation,
  SubagentBasicEntry,
  SubagentEntry,
  TestSnapshot,
  ThinkingBlockAnalysis,
  ToolError,
  ToolSuccessRate,
  UserQuestion,
} from '@renderer/types/sessionReport';
import type {
  ContentBlock,
  ParsedMessage,
  Process,
  SessionDetail,
  TextContent,
  ThinkingContent,
  ToolCall,
} from '@shared/types';

// Re-export getDisplayPricing as getPricing for backward compat with CostSection
export { getDisplayPricing as getPricing } from '@shared/utils/pricing';

// =============================================================================
// Helpers
// =============================================================================

function isTextBlock(block: ContentBlock): block is TextContent {
  return block.type === 'text';
}

function isThinkingBlock(block: ContentBlock): block is ThinkingContent {
  return block.type === 'thinking';
}

function extractTextContent(msg: ParsedMessage): string {
  const { content } = msg;
  if (typeof content === 'string') return content;
  if (Array.isArray(content)) {
    return content
      .filter(isTextBlock)
      .map((block) => block.text)
      .join(' ');
  }
  return '';
}

function formatDuration(totalSeconds: number): string {
  const h = Math.floor(totalSeconds / 3600);
  const m = Math.floor((totalSeconds % 3600) / 60);
  const s = Math.floor(totalSeconds % 60);
  if (h > 0) return `${h}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
  return `${m}:${String(s).padStart(2, '0')}`;
}

// Friction keyword patterns
const FRICTION_PATTERNS: [RegExp, string][] = [
  [/\bno,/i, 'no,'],
  [/\bwrong\b/i, 'wrong'],
  [/\bactually\b/i, 'actually'],
  [/\bundo\b/i, 'undo'],
  [/\brevert\b/i, 'revert'],
  [/that's not\b/i, "that's not"],
  [/\binstead,/i, 'instead,'],
  [/\bwait,/i, 'wait,'],
  [/\bnevermind\b/i, 'nevermind'],
  [/I don't want\b/i, "I don't want"],
];

// Permission denial keywords (case-insensitive substring match)
const PERMISSION_KEYWORDS = [
  'permission denied',
  'not allowed',
  'requires approval',
  'cannot execute',
  'access denied',
  'operation not permitted',
  'eacces',
  'eperm',
  'user rejected',
  'user denied',
  'needs_user_approval',
];

function isPermissionDenial(text: string): boolean {
  const lower = text.toLowerCase();
  return PERMISSION_KEYWORDS.some((kw) => lower.includes(kw));
}

/**
 * Extract a number immediately before a keyword in text.
 * E.g., extractNumberBefore("42 passed", "passed") => 42
 */
function extractNumberBefore(text: string, keyword: string): number | null {
  const idx = text.toLowerCase().indexOf(keyword.toLowerCase());
  if (idx <= 0) return null;
  const before = text.slice(Math.max(0, idx - 15), idx).trim();
  const parts = before.split(/\s+/);
  const numStr = parts[parts.length - 1];
  if (numStr && /^\d+$/.test(numStr)) return parseInt(numStr, 10);
  return null;
}

/**
 * Parse test summary from command output.
 * Returns [passed, failed] or null if no match.
 */
function parseTestSummary(text: string): [number, number] | null {
  // Try "passed"/"failed" keywords — treat missing count as 0
  // (runners often omit "0 failed" when all tests pass)
  const passed = extractNumberBefore(text, ' passed');
  const failed = extractNumberBefore(text, ' failed');
  if (passed != null || failed != null) return [passed ?? 0, failed ?? 0];

  // Try "passing"/"failing" keywords (mocha-style)
  const passing = extractNumberBefore(text, ' passing');
  const failing = extractNumberBefore(text, ' failing');
  if (passing != null || failing != null) return [passing ?? 0, failing ?? 0];

  return null;
}

// Thinking block analysis signals
const THINKING_SIGNALS: Record<string, RegExp> = {
  alternatives: /\balternative(?:ly|s)?\b|\binstead\b|\bother approach\b|\bcould also\b/i,
  uncertainty: /\bnot sure\b|\buncertain\b|\bmight be\b|\bpossibly\b|\bI think\b.*\bbut\b/i,
  errors_noticed: /\bbug\b|\berror\b|\bwrong\b|\bincorrect\b|\bfail\b|\bbroken\b/i,
  planning: /\bfirst.*then\b|\bstep \d\b|\bplan\b|\bapproach\b|\bstrategy\b/i,
  direction_change: /\bwait\b|\bactually\b|\bon second thought\b|\blet me reconsider\b|\bhmm\b/i,
};

// "Work" tools (non-Skill) for startup overhead detection
const NON_SKILL_TOOLS = new Set([
  'Read',
  'Write',
  'Edit',
  'Bash',
  'Grep',
  'Glob',
  'Task',
  'WebFetch',
  'WebSearch',
  'NotebookEdit',
]);

// =============================================================================
// Main Analyzer
// =============================================================================

export function analyzeSession(detail: SessionDetail): SessionReport {
  const { session, messages } = detail;

  // --- Session Overview ---
  const timestamps = messages.filter((m) => m.timestamp).map((m) => m.timestamp);
  const firstTs = timestamps.length > 0 ? timestamps[0] : null;
  const lastTs = timestamps.length > 0 ? timestamps[timestamps.length - 1] : null;
  const durationMs = firstTs && lastTs ? lastTs.getTime() - firstTs.getTime() : 0;
  const durationSeconds = durationMs / 1000;

  // Context consumption interpretation
  const ctxConsumption = session.contextConsumption ?? 0;
  let ctxConsumptionPct: number | null = null;
  let ctxAssessment: 'critical' | 'high' | 'moderate' | 'healthy' | null = null;
  if (ctxConsumption <= 1) {
    ctxConsumptionPct = ctxConsumption ? Math.round(ctxConsumption * 1000) / 10 : 0;
    if (ctxConsumption > 0.8) ctxAssessment = 'critical';
    else if (ctxConsumption > 0.6) ctxAssessment = 'high';
    else if (ctxConsumption > 0.4) ctxAssessment = 'moderate';
    else ctxAssessment = 'healthy';
  }

  // ===================================================================
  // SINGLE-PASS ACCUMULATORS
  // ===================================================================

  // Token usage by model
  const modelStats = new Map<string, ModelTokenStats>();

  const getModelStats = (model: string): ModelTokenStats => {
    let stats = modelStats.get(model);
    if (!stats) {
      stats = {
        apiCalls: 0,
        inputTokens: 0,
        outputTokens: 0,
        cacheCreation: 0,
        cacheRead: 0,
        costUsd: 0,
      };
      modelStats.set(model, stats);
    }
    return stats;
  };

  // Cache economics
  let totalCacheCreation = 0;
  let totalCacheRead = 0;
  let coldStartDetected = false;
  let firstAssistantWithUsageSeen = false;

  // Message type counts
  const typeCounts = new Map<string, number>();

  // Tool usage counts
  const toolCounts = new Map<string, number>();

  // Tool call index: toolUseId -> [messageIndex, toolCall]
  const toolCallIndex = new Map<string, [number, ToolCall]>();

  // Tool errors
  const errors: ToolError[] = [];
  const errorsByTool = new Map<string, number>();

  // Permission denials
  const permissionDenials: ToolError[] = [];

  // Key events
  const keyEvents: KeyEvent[] = [];

  // Thinking blocks
  let thinkingCount = 0;
  const thinkingAnalysis: ThinkingBlockAnalysis[] = [];

  // Git branches
  const branches = new Set<string>();

  // Friction signals
  const corrections: FrictionCorrection[] = [];
  let userMessageCount = 0;

  // Thrashing detection
  const bashPrefixGroups = new Map<string, number>();
  const fileEditIndices = new Map<string, number[]>();

  // Startup overhead
  let firstWorkToolSeen = false;
  let startupMessages = 0;
  let startupTokens = 0;

  // Token density timeline
  const assistantMsgData: [Date, number][] = [];

  // Conversation tree
  const uuidToIdx = new Map<string, number>();
  const parentMap = new Map<string, string | null>();
  let sidechainCount = 0;
  const childrenMap = new Map<string, string[]>();

  // Idle gap detection
  let lastAssistantTs: Date | null = null;
  const idleGaps: IdleGap[] = [];
  const IDLE_THRESHOLD_SEC = 60;

  // Model switch detection
  let lastModel: string | null = null;
  const modelSwitches: ModelSwitch[] = [];

  // Working directory tracking
  const cwdSet = new Set<string>();
  const cwdChanges: { from: string; to: string; messageIndex: number }[] = [];
  let lastCwd: string | null = null;

  // Test progression
  const testSnapshots: TestSnapshot[] = [];

  // Cost tracking
  let parentCost = 0;

  // Git activity
  const gitCommits: GitCommit[] = [];
  let gitPushCount = 0;
  const gitBranchCreations: string[] = [];
  let linesAddedTotal = 0;
  let linesRemovedTotal = 0;

  // File read redundancy
  const fileReadCounts = new Map<string, number>();

  // First user message length
  let firstUserMessageLength = 0;
  let firstUserSeen = false;

  // Skills invoked
  const skillsInvoked: SkillInvocation[] = [];

  // Bash commands
  const bashCmds: string[] = [];

  // Subagents list (backward compat)
  const subagentsList: SubagentBasicEntry[] = [];

  // Lifecycle tasks
  const lifecycleTasks: string[] = [];

  // User questions
  const userQuestions: UserQuestion[] = [];

  // Out-of-scope findings
  const OUT_OF_SCOPE_KEYWORDS = [
    'pre-existing',
    'out of scope',
    'tech debt',
    'anti-pattern',
    'existed before',
  ];
  const outOfScopeFindings: OutOfScopeFindings[] = [];

  // Agent tree metadata
  const agentTreeNodes: AgentTreeNode[] = [];

  // Compact summary count

  let compactSummaryCount = 0;

  // ===================================================================
  // SINGLE PASS
  // ===================================================================

  for (let i = 0; i < messages.length; i++) {
    const m = messages[i];
    const msgType = m.type ?? 'unknown';
    typeCounts.set(msgType, (typeCounts.get(msgType) ?? 0) + 1);
    const msgUuid = m.uuid ?? '';
    const msgParent = m.parentUuid ?? '';
    const msgTs = m.timestamp;

    // --- Conversation tree ---
    if (msgUuid) {
      uuidToIdx.set(msgUuid, i);
      parentMap.set(msgUuid, msgParent || null);
      if (msgParent) {
        const children = childrenMap.get(msgParent);
        if (children) children.push(msgUuid);
        else childrenMap.set(msgParent, [msgUuid]);
      }
    }

    if (m.isSidechain) sidechainCount++;

    // --- Working directory tracking ---
    const msgCwd = m.cwd ?? '';
    if (msgCwd) {
      cwdSet.add(msgCwd);
      if (lastCwd && msgCwd !== lastCwd) {
        cwdChanges.push({ from: lastCwd, to: msgCwd, messageIndex: i });
      }
      lastCwd = msgCwd;
    }

    // --- Token usage, cache economics, and cost ---
    // Skip sidechain messages to avoid double-counting (subagent costs are
    // accounted for separately via processSubagentCost).
    if (m.usage && m.model && !m.isSidechain && m.model !== '<synthetic>') {
      const model = m.model;
      const u = m.usage;
      const inpTok = u.input_tokens ?? 0;
      const outTok = u.output_tokens ?? 0;
      const cc = u.cache_creation_input_tokens ?? 0;
      const cr = u.cache_read_input_tokens ?? 0;

      const stats = getModelStats(model);
      stats.apiCalls += 1;
      stats.inputTokens += inpTok;
      stats.outputTokens += outTok;
      stats.cacheCreation += cc;
      stats.cacheRead += cr;

      const callCost = calculateMessageCost(model, inpTok, outTok, cr, cc);
      stats.costUsd += callCost;
      parentCost += callCost;

      totalCacheCreation += cc;
      totalCacheRead += cr;

      // Cold start detection
      if (msgType === 'assistant' && !firstAssistantWithUsageSeen) {
        firstAssistantWithUsageSeen = true;
        if (cc > 0 && cr === 0) coldStartDetected = true;
      }
    }

    // --- Git branches ---
    if (m.gitBranch) branches.add(m.gitBranch);

    // --- Compact summaries ---
    if (m.isCompactSummary) compactSummaryCount++;

    // --- Agent tree metadata ---
    if (m.agentId) {
      // agentType/teamName/parentToolUseId may exist on raw data but not typed in ParsedMessage
      const raw = m as unknown as Record<string, unknown>;
      agentTreeNodes.push({
        agentId: m.agentId,
        agentType: (raw.agentType as string) ?? 'unknown',
        teamName: (raw.teamName as string) ?? '',
        parentToolUseId: (raw.parentToolUseId as string) ?? '',
        messageIndex: i,
      });
    }

    // --- Thinking blocks (with content analysis) ---
    if (Array.isArray(m.content)) {
      for (const block of m.content) {
        if (isThinkingBlock(block)) {
          thinkingCount++;
          const thinkText = block.thinking ?? '';
          const signalsFound: Record<string, boolean> = {};
          for (const [signalName, pattern] of Object.entries(THINKING_SIGNALS)) {
            if (pattern.test(thinkText)) signalsFound[signalName] = true;
          }
          if (Object.keys(signalsFound).length > 0 || thinkingCount <= 5) {
            thinkingAnalysis.push({
              messageIndex: i,
              preview: thinkText.slice(0, 200).replace(/\n/g, ' ').trim(),
              charLength: thinkText.length,
              signals: signalsFound,
            });
          }
        }
      }
    }

    // --- Model switch detection ---
    if (msgType === 'assistant' && m.model) {
      const currentModel = m.model;
      if (lastModel && currentModel !== lastModel) {
        modelSwitches.push({
          from: lastModel,
          to: currentModel,
          messageIndex: i,
          timestamp: msgTs ?? null,
        });
      }
      lastModel = currentModel;
    }

    // --- Idle gap detection ---
    if (msgType === 'assistant' && msgTs) {
      lastAssistantTs = msgTs;
    }
    if (msgType === 'user' && msgTs && lastAssistantTs) {
      const gap = (msgTs.getTime() - lastAssistantTs.getTime()) / 1000;
      if (gap > IDLE_THRESHOLD_SEC) {
        idleGaps.push({
          gapSeconds: Math.round(gap * 10) / 10,
          gapHuman: formatDuration(Math.floor(gap)),
          afterMessageIndex: i,
        });
      }
    }

    // --- First user message length (prompt quality) ---
    if (msgType === 'user' && !firstUserSeen && !m.isMeta) {
      const contentText = extractTextContent(m);
      if (contentText.trim()) {
        firstUserMessageLength = contentText.length;
        firstUserSeen = true;
      }
    }

    // --- Tool calls (assistant messages) ---
    for (const tc of m.toolCalls) {
      const toolName = tc.name;
      toolCounts.set(toolName, (toolCounts.get(toolName) ?? 0) + 1);
      if (tc.id) toolCallIndex.set(tc.id, [i, tc]);
      const inp = tc.input ?? {};

      // Bash commands
      if (toolName === 'Bash') {
        const cmd = typeof inp.command === 'string' ? inp.command : '';
        const cmdTrunc = cmd.slice(0, 200);
        bashCmds.push(cmdTrunc);
        // Thrashing: bash prefix groups
        const prefix = cmd.slice(0, 40);
        bashPrefixGroups.set(prefix, (bashPrefixGroups.get(prefix) ?? 0) + 1);

        // Git activity
        if (cmd.includes('git commit')) {
          const heredocMatch = /cat\s+<<['"]?EOF['"]?\n(.+?)(?:\n|$)/.exec(cmd);
          let preview: string;
          if (heredocMatch) {
            preview = heredocMatch[1].trim().slice(0, 80);
          } else {
            const msgMatch = /-m\s+["'](.+?)["']/.exec(cmd);
            preview = msgMatch ? msgMatch[1].slice(0, 80) : cmd.slice(0, 80);
          }
          gitCommits.push({ messagePreview: preview, messageIndex: i });
        }
        if (cmd.includes('git push')) gitPushCount++;
        if (cmd.includes('git checkout -b') || cmd.includes('git switch -c')) {
          const branchMatch = /git (?:checkout -b|switch -c)\s+(\S+)/.exec(cmd);
          if (branchMatch) gitBranchCreations.push(branchMatch[1]);
        }
      }

      // Skills
      if (toolName === 'Skill') {
        skillsInvoked.push({
          skill: (inp.skill as string) ?? 'unknown',
          argsPreview: (typeof inp.args === 'string'
            ? inp.args
            : JSON.stringify(inp.args ?? '')
          ).slice(0, 120),
        });
      }

      // Task (subagent list)
      if (toolName === 'Task') {
        subagentsList.push({
          description: (inp.description as string) ?? 'unknown',
          subagentType: (inp.subagent_type as string) ?? 'unknown',
          model: (inp.model as string) ?? 'default (inherits parent)',
          runInBackground: (inp.run_in_background as boolean) ?? false,
        });
      }

      // TaskCreate
      if (toolName === 'TaskCreate') {
        lifecycleTasks.push((inp.subject as string) ?? 'unknown');
      }

      // AskUserQuestion
      if (toolName === 'AskUserQuestion') {
        const questions = inp.questions as { question?: string; options?: { label?: string }[] }[];
        if (Array.isArray(questions)) {
          for (const q of questions) {
            userQuestions.push({
              question: q.question ?? '',
              options: Array.isArray(q.options) ? q.options.map((o) => o.label ?? '') : [],
            });
          }
        }
      }

      // File reads
      if (toolName === 'Read') {
        const filePath = (inp.file_path as string) ?? '';
        if (filePath) {
          fileReadCounts.set(filePath, (fileReadCounts.get(filePath) ?? 0) + 1);
        }
      }

      // Write/Edit for thrashing
      if (toolName === 'Write' || toolName === 'Edit') {
        const fp = (inp.file_path as string) ?? '';
        if (fp) {
          const indices = fileEditIndices.get(fp);
          if (indices) indices.push(i);
          else fileEditIndices.set(fp, [i]);
        }
      }

      // Startup overhead: track first non-Skill tool call
      if (!firstWorkToolSeen && NON_SKILL_TOOLS.has(toolName)) {
        firstWorkToolSeen = true;
      }
    }

    // --- Startup overhead: count assistant messages before first work tool ---
    if (msgType === 'assistant' && !firstWorkToolSeen) {
      startupMessages++;
      if (m.usage) {
        startupTokens += m.usage.output_tokens ?? 0;
        startupTokens += m.usage.input_tokens ?? 0;
        startupTokens += m.usage.cache_creation_input_tokens ?? 0;
        startupTokens += m.usage.cache_read_input_tokens ?? 0;
      }
    }

    // --- Token density timeline ---
    if (msgType === 'assistant' && msgTs && m.usage) {
      const totalMsgTokens =
        (m.usage.input_tokens ?? 0) +
        (m.usage.output_tokens ?? 0) +
        (m.usage.cache_creation_input_tokens ?? 0) +
        (m.usage.cache_read_input_tokens ?? 0);
      assistantMsgData.push([msgTs, totalMsgTokens]);
    }

    // --- Timing / key events ---
    if (msgTs) {
      let label: string | null = null;
      if (msgType === 'user' && typeof m.content === 'string') {
        const content = m.content;
        if (content.includes('start feature')) {
          label = `User: ${content.slice(0, 60)}`;
        } else if (content.includes('being continued')) {
          label = 'Context compaction/continuation';
        }
      }

      for (const tc of m.toolCalls) {
        if (tc.name === 'Skill') {
          label = `Skill: ${(tc.input.skill as string) ?? ''}`;
        } else if (tc.name === 'Task') {
          const inpTc = tc.input ?? {};
          label = `Task: ${(inpTc.description as string) ?? ''} (${(inpTc.subagent_type as string) ?? ''})`;
        }
      }

      if (label) {
        keyEvents.push({ timestamp: msgTs, label });
      }
    }

    // --- Friction signals (user messages) ---
    if (msgType === 'user' && !m.isMeta) {
      const contentText = extractTextContent(m);
      if (contentText.trim()) {
        userMessageCount++;
        for (const [regex, keyword] of FRICTION_PATTERNS) {
          if (regex.test(contentText)) {
            corrections.push({
              messageIndex: i,
              keyword,
              preview: contentText.slice(0, 120).replace(/\n/g, ' '),
            });
            break;
          }
        }
      }
    }

    // --- Out-of-scope findings (assistant messages) ---
    if (msgType === 'assistant') {
      const contentText = extractTextContent(m);
      const contentLower = contentText.toLowerCase();
      for (const kw of OUT_OF_SCOPE_KEYWORDS) {
        const kwIdx = contentLower.indexOf(kw.toLowerCase());
        if (kwIdx >= 0) {
          const start = Math.max(0, kwIdx - 80);
          const end = Math.min(contentText.length, kwIdx + 300);
          outOfScopeFindings.push({
            keyword: kw,
            messageIndex: i,
            snippet: contentText.slice(start, end).replace(/\n/g, ' ').trim(),
          });
          break;
        }
      }
    }

    // --- Tool results ---
    for (const tr of m.toolResults) {
      const toolUseId = tr.toolUseId;
      if (!toolUseId) continue;
      const contentStr = typeof tr.content === 'string' ? tr.content : JSON.stringify(tr.content);

      // Tool errors
      if (tr.isError) {
        let toolName = 'unknown';
        let toolInput = '';
        const indexed = toolCallIndex.get(toolUseId);
        if (indexed) {
          const [, tc] = indexed;
          toolName = tc.name ?? 'unknown';
          toolInput = JSON.stringify(tc.input ?? {}).slice(0, 300);
        }

        const errorEntry: ToolError = {
          tool: toolName,
          inputPreview: toolInput,
          error: contentStr.slice(0, 500),
          messageIndex: i,
          isPermissionDenial: false,
        };

        if (isPermissionDenial(contentStr)) {
          errorEntry.isPermissionDenial = true;
          permissionDenials.push(errorEntry);
        }

        errors.push(errorEntry);
        errorsByTool.set(toolName, (errorsByTool.get(toolName) ?? 0) + 1);
      }

      // Bash exit code errors
      if (
        !tr.isError &&
        (contentStr.includes('Exit code 1') || contentStr.includes('Exit code 127'))
      ) {
        const indexed = toolCallIndex.get(toolUseId);
        if (indexed) {
          const [, tc] = indexed;
          if (tc.name === 'Bash') {
            const bashError: ToolError = {
              tool: 'Bash (non-zero exit)',
              inputPreview: JSON.stringify(tc.input ?? {}).slice(0, 300),
              error: contentStr.slice(0, 500),
              messageIndex: i,
              isPermissionDenial: false,
            };
            if (isPermissionDenial(contentStr)) {
              bashError.isPermissionDenial = true;
              permissionDenials.push(bashError);
            }
            errors.push(bashError);
            errorsByTool.set(
              'Bash (non-zero exit)',
              (errorsByTool.get('Bash (non-zero exit)') ?? 0) + 1
            );
          }
        }
      }

      // --- Test progression: parse test output from bash results ---
      const indexedForTest = toolCallIndex.get(toolUseId);
      if (indexedForTest) {
        const [, tcOrig] = indexedForTest;
        if (tcOrig.name === 'Bash') {
          const testResult = parseTestSummary(contentStr);
          if (testResult) {
            const [passed, failed] = testResult;
            testSnapshots.push({
              messageIndex: i,
              passed,
              failed,
              total: passed + failed,
              raw: contentStr.slice(0, 200).replace(/\n/g, ' '),
            });
          }
        }
      }

      // --- Lines changed: parse git diff --stat output ---
      const indexedForDiff = toolCallIndex.get(toolUseId);
      if (indexedForDiff) {
        const [, tcOrig] = indexedForDiff;
        if (tcOrig.name === 'Bash') {
          const rawCmd = tcOrig.input?.command;
          const cmdText = typeof rawCmd === 'string' ? rawCmd : '';
          if (cmdText.includes('git diff') || cmdText.includes('git show')) {
            const insertionIdx = contentStr.indexOf(' insertion');
            const deletionIdx = contentStr.indexOf(' deletion');
            if (insertionIdx > 0) {
              const numStr = contentStr
                .slice(Math.max(0, insertionIdx - 10), insertionIdx)
                .trim()
                .split(/\s+/)
                .pop();
              if (numStr && /^\d+$/.test(numStr)) linesAddedTotal += parseInt(numStr, 10);
            }
            if (deletionIdx > 0) {
              const numStr = contentStr
                .slice(Math.max(0, deletionIdx - 10), deletionIdx)
                .trim()
                .split(/\s+/)
                .pop();
              if (numStr && /^\d+$/.test(numStr)) linesRemovedTotal += parseInt(numStr, 10);
            }
          }
        }
      }
    }
  }

  // ===================================================================
  // POST-PASS AGGREGATION
  // ===================================================================

  // --- Token usage ---
  let totalInputTokens = 0;
  let totalOutputTokens = 0;
  let totalCacheCreationTokens = 0;
  let totalCacheReadTokens = 0;

  const byModel: Record<string, ModelTokenStats> = {};
  for (const [model, stats] of modelStats) {
    stats.costUsd = Math.round(stats.costUsd * 10000) / 10000;
    byModel[model] = stats;
    totalInputTokens += stats.inputTokens;
    totalOutputTokens += stats.outputTokens;
    totalCacheCreationTokens += stats.cacheCreation;
    totalCacheReadTokens += stats.cacheRead;
  }

  let grandTotal =
    totalInputTokens + totalOutputTokens + totalCacheCreationTokens + totalCacheReadTokens;

  // --- Cost analysis ---
  const commitCount = gitCommits.length;
  const linesChanged = linesAddedTotal + linesRemovedTotal;

  // --- Subagent metrics from detail.processes ---
  const subagentEntries: SubagentEntry[] = detail.processes.map((proc: Process) => {
    const desc = proc.description ?? 'unknown';
    // Extract actual model from subagent messages (first assistant message with a model field)
    const subagentModel =
      proc.messages.find((m: ParsedMessage) => m.type === 'assistant' && m.model)?.model ??
      'default (inherits parent)';
    // Compute cost from subagent token breakdown (proc.metrics.costUsd is not populated upstream)
    const computedCost = calculateMessageCost(
      subagentModel,
      proc.metrics.inputTokens,
      proc.metrics.outputTokens,
      proc.metrics.cacheReadTokens,
      proc.metrics.cacheCreationTokens
    );
    return {
      description: desc,
      subagentType: proc.subagentType ?? 'unknown',
      model: subagentModel,
      totalTokens: proc.metrics.totalTokens,
      totalDurationMs: proc.durationMs,
      totalToolUseCount: proc.messages.reduce(
        (sum: number, pm: ParsedMessage) => sum + pm.toolCalls.length,
        0
      ),
      costUsd: computedCost,
      modelMismatch: detectModelMismatch(desc, subagentModel),
    };
  });

  const saFromProcesses = {
    count: subagentEntries.length,
    totalTokens: subagentEntries.reduce((sum, a) => sum + a.totalTokens, 0),
    totalDurationMs: subagentEntries.reduce((sum, a) => sum + a.totalDurationMs, 0),
    totalToolUseCount: subagentEntries.reduce((sum, a) => sum + a.totalToolUseCount, 0),
    totalCostUsd:
      Math.round(subagentEntries.reduce((sum, a) => sum + a.costUsd, 0) * 10000) / 10000,
    byAgent: subagentEntries,
  };

  // --- Tool usage with success rates ---
  const toolSuccessRates: Record<string, ToolSuccessRate> = {};
  const sortedToolCounts = [...toolCounts.entries()].sort((a, b) => b[1] - a[1]);
  const countsRecord: Record<string, number> = {};
  for (const [tool, count] of sortedToolCounts) {
    countsRecord[tool] = count;
    const errCount = errorsByTool.get(tool) ?? 0;
    const successPct = count ? Math.round(((count - errCount) / count) * 1000) / 10 : 0;
    toolSuccessRates[tool] = {
      totalCalls: count,
      errors: errCount,
      successRatePct: successPct,
      assessment: computeToolHealthAssessment(successPct),
    };
  }

  // Overall tool health: worst assessment among tools with >5 calls
  const significantTools = Object.values(toolSuccessRates).filter((t) => t.totalCalls > 5);
  type THAssessment = 'healthy' | 'degraded' | 'unreliable';
  const overallToolHealth: THAssessment =
    significantTools.length > 0
      ? significantTools.reduce<THAssessment>((worst, t) => {
          const order = { healthy: 0, degraded: 1, unreliable: 2 } as const;
          return order[t.assessment] > order[worst] ? t.assessment : worst;
        }, 'healthy')
      : computeToolHealthAssessment(100);

  // --- Key events timing ---
  for (let j = 1; j < keyEvents.length; j++) {
    const prevDt = keyEvents[j - 1].timestamp;
    const currDt = keyEvents[j].timestamp;
    const delta = (currDt.getTime() - prevDt.getTime()) / 1000;
    keyEvents[j].deltaSeconds = Math.round(delta * 10) / 10;
    keyEvents[j].deltaHuman = formatDuration(Math.floor(delta));
  }

  // --- Thinking blocks signal aggregation ---
  const signalTotals: Record<string, number> = {};
  for (const ta of thinkingAnalysis) {
    for (const sig of Object.keys(ta.signals)) {
      signalTotals[sig] = (signalTotals[sig] ?? 0) + 1;
    }
  }

  // --- Cache economics ---
  const cacheTotalCreationAndRead = totalCacheCreation + totalCacheRead;
  const cacheEfficiency = cacheTotalCreationAndRead
    ? Math.round((totalCacheRead / cacheTotalCreationAndRead) * 10000) / 100
    : 0;
  const cacheRwRatio = totalCacheCreation
    ? Math.round((totalCacheRead / totalCacheCreation) * 10) / 10
    : 0;

  // --- File read redundancy ---
  let totalReads = 0;
  const redundantFiles: Record<string, number> = {};
  for (const [path, count] of fileReadCounts) {
    totalReads += count;
    if (count > 2) redundantFiles[path] = count;
  }
  const uniqueFiles = fileReadCounts.size;

  // --- Token density timeline ---
  const quartiles: { q: number; avgTokens: number; messageCount: number }[] = [];
  if (assistantMsgData.length > 0) {
    const n = assistantMsgData.length;
    const qSize = Math.max(1, Math.floor(n / 4));
    for (let q = 0; q < 4; q++) {
      const startIdx = q * qSize;
      const endIdx = q === 3 ? n : (q + 1) * qSize;
      const chunk = assistantMsgData.slice(startIdx, endIdx);
      if (chunk.length > 0) {
        const avgTokens = Math.round(chunk.reduce((sum, [, t]) => sum + t, 0) / chunk.length);
        quartiles.push({ q: q + 1, avgTokens, messageCount: chunk.length });
      } else {
        quartiles.push({ q: q + 1, avgTokens: 0, messageCount: 0 });
      }
    }
  } else {
    for (let q = 0; q < 4; q++) {
      quartiles.push({ q: q + 1, avgTokens: 0, messageCount: 0 });
    }
  }

  // --- Conversation tree analysis ---
  const depthMemo = new Map<string, number>();
  function getDepth(uuid: string, visited = new Set<string>()): number {
    if (depthMemo.has(uuid)) return depthMemo.get(uuid)!;
    if (visited.has(uuid)) {
      depthMemo.set(uuid, 0);
      return 0;
    }
    visited.add(uuid);
    const parent = parentMap.get(uuid);
    if (!parent) {
      depthMemo.set(uuid, 0);
      return 0;
    }
    const depth = 1 + getDepth(parent, visited);
    depthMemo.set(uuid, depth);
    return depth;
  }

  let maxDepth = 0;
  for (const uuid of parentMap.keys()) {
    const d = getDepth(uuid);
    if (d > maxDepth) maxDepth = d;
  }

  // Branch points: parents with multiple children
  const branchPoints = new Map<string, string[]>();
  for (const [parent, children] of childrenMap) {
    if (children.length > 1) branchPoints.set(parent, children);
  }

  const branchDetails = [...branchPoints.entries()]
    .sort((a, b) => b[1].length - a[1].length)
    .slice(0, 10)
    .map(([p, c]) => ({
      parentUuid: p.slice(0, 12) + '...',
      childCount: c.length,
      parentMessageIndex: uuidToIdx.get(p),
    }));

  // --- Idle gap analysis ---
  const totalIdle = idleGaps.reduce((sum, g) => sum + g.gapSeconds, 0);
  const wallClock = durationSeconds;
  const activeTime = wallClock > 0 ? wallClock - totalIdle : 0;

  // --- Thrashing signals ---
  const bashNearDuplicates = [...bashPrefixGroups.entries()]
    .filter(([, count]) => count > 2)
    .sort((a, b) => b[1] - a[1])
    .map(([prefix, count]) => ({ prefix, count }));

  const editReworkFiles = [...fileEditIndices.entries()]
    .filter(([, indices]) => indices.length >= 3)
    .map(([filePath, editIndices]) => ({ filePath, editIndices }));

  // --- Model switches ---
  const modelsUsed =
    modelSwitches.length > 0
      ? [...new Set([...modelSwitches.map((s) => s.from), ...modelSwitches.map((s) => s.to)])]
      : [...modelStats.keys()];

  // --- Test progression trajectory ---
  let trajectory: 'improving' | 'regressing' | 'stable' | 'insufficient_data' = 'insufficient_data';
  if (testSnapshots.length >= 2) {
    const first = testSnapshots[0];
    const last = testSnapshots[testSnapshots.length - 1];
    if (last.passed > first.passed) trajectory = 'improving';
    else if (last.passed < first.passed) trajectory = 'regressing';
    else trajectory = 'stable';
  }

  // --- Prompt quality assessment ---
  const correctionCount = corrections.length;
  const frictionRate = userMessageCount
    ? Math.round((correctionCount / userMessageCount) * 10000) / 10000
    : 0;

  type PromptAssessment =
    | 'underspecified'
    | 'verbose_but_unclear'
    | 'well_specified'
    | 'moderate_friction';

  let assessment: PromptAssessment;
  let promptNote: string;

  if (firstUserMessageLength < 100 && correctionCount >= 2) {
    assessment = 'underspecified';
    promptNote =
      'Short initial prompt with multiple corrections suggests the task needed more upfront specification.';
  } else if (firstUserMessageLength > 500 && correctionCount >= 3) {
    assessment = 'verbose_but_unclear';
    promptNote =
      'Initial prompt was detailed but still required corrections — consider restructuring for clarity.';
  } else if (correctionCount <= 1) {
    assessment = 'well_specified';
    promptNote = 'Low friction — initial prompt effectively communicated intent.';
  } else {
    assessment = 'moderate_friction';
    promptNote =
      'Moderate friction detected — review correction patterns for improvement opportunities.';
  }

  // --- Message types ---
  const messageTypes: Record<string, number> = {};
  for (const [type, count] of typeCounts) {
    messageTypes[type] = count;
  }

  // --- Subagent cost from processes ---
  const processSubagentCost = subagentEntries.reduce((sum, a) => sum + a.costUsd, 0);
  const totalCost = parentCost + processSubagentCost;

  // Add aggregated subagent row to costByModel and byModel for the cost table
  if (subagentEntries.length > 0 && processSubagentCost > 0) {
    const subagentTokenStats: ModelTokenStats = {
      apiCalls: 0,
      inputTokens: 0,
      outputTokens: 0,
      cacheCreation: 0,
      cacheRead: 0,
      costUsd: 0,
    };
    for (const proc of detail.processes) {
      subagentTokenStats.inputTokens += proc.metrics.inputTokens;
      subagentTokenStats.outputTokens += proc.metrics.outputTokens;
      subagentTokenStats.cacheCreation += proc.metrics.cacheCreationTokens;
      subagentTokenStats.cacheRead += proc.metrics.cacheReadTokens;
      // Count assistant messages with usage as API calls
      subagentTokenStats.apiCalls += proc.messages.filter(
        (m: ParsedMessage) => m.type === 'assistant' && m.usage
      ).length;
    }
    subagentTokenStats.costUsd = Math.round(processSubagentCost * 10000) / 10000;
    const subagentLabel = 'Subagents (combined)';
    byModel[subagentLabel] = subagentTokenStats;
    modelStats.set(subagentLabel, subagentTokenStats);

    // Update totals to include subagent tokens so the footer row stays consistent
    totalInputTokens += subagentTokenStats.inputTokens;
    totalOutputTokens += subagentTokenStats.outputTokens;
    totalCacheCreationTokens += subagentTokenStats.cacheCreation;
    totalCacheReadTokens += subagentTokenStats.cacheRead;
    grandTotal =
      totalInputTokens + totalOutputTokens + totalCacheCreationTokens + totalCacheReadTokens;
  }

  // --- Assessment computations ---
  const costPerCommitVal =
    commitCount > 0 ? Math.round((totalCost / commitCount) * 10000) / 10000 : null;
  const costPerLineVal =
    linesChanged > 0 ? Math.round((totalCost / linesChanged) * 1000000) / 1000000 : null;
  const subagentCostSharePct =
    totalCost > 0 ? Math.round((processSubagentCost / totalCost) * 10000) / 100 : null;

  const readsPerUniqueFile = uniqueFiles ? Math.round((totalReads / uniqueFiles) * 100) / 100 : 0;
  const startupPctOfTotal = grandTotal ? Math.round((startupTokens / grandTotal) * 10000) / 100 : 0;
  const idlePct = wallClock > 0 ? Math.round((totalIdle / wallClock) * 1000) / 10 : 0;
  const thrashingSignalCount = bashNearDuplicates.length + editReworkFiles.length;

  // ===================================================================
  // BUILD REPORT
  // ===================================================================

  const report: SessionReport = {
    overview: {
      sessionId: session.id,
      projectId: session.projectId ?? 'unknown',
      projectPath: session.projectPath ?? 'unknown',
      firstMessage: session.firstMessage ?? 'unknown',
      messageCount: session.messageCount ?? 0,
      hasSubagents: session.hasSubagents ?? false,
      contextConsumption: ctxConsumption,
      contextConsumptionPct: ctxConsumptionPct,
      contextAssessment: ctxAssessment,
      compactionCount: session.compactionCount ?? 0,
      gitBranch: session.gitBranch ?? 'unknown',
      startTime: firstTs,
      endTime: lastTs,
      durationSeconds,
      durationHuman: durationSeconds > 0 ? formatDuration(Math.floor(durationSeconds)) : 'unknown',
      totalMessages: messages.length,
    },

    tokenUsage: {
      byModel,
      totals: {
        inputTokens: totalInputTokens,
        outputTokens: totalOutputTokens,
        cacheCreation: totalCacheCreationTokens,
        cacheRead: totalCacheReadTokens,
        grandTotal,
        cacheReadPct: grandTotal
          ? Math.round((totalCacheReadTokens / grandTotal) * 10000) / 100
          : 0,
      },
    },

    costAnalysis: {
      parentCostUsd: Math.round(parentCost * 10000) / 10000,
      subagentCostUsd: Math.round(processSubagentCost * 10000) / 10000,
      totalSessionCostUsd: Math.round(totalCost * 10000) / 10000,
      costByModel: Object.fromEntries(
        [...modelStats.entries()].map(([model, stats]) => [
          model,
          Math.round(stats.costUsd * 10000) / 10000,
        ])
      ),
      costPerCommit: costPerCommitVal,
      costPerLineChanged: costPerLineVal,
      costPerCommitAssessment:
        costPerCommitVal != null ? computeCostPerCommitAssessment(costPerCommitVal) : null,
      costPerLineAssessment:
        costPerLineVal != null ? computeCostPerLineAssessment(costPerLineVal) : null,
      subagentCostSharePct,
      subagentCostShareAssessment:
        subagentCostSharePct != null
          ? computeSubagentCostShareAssessment(subagentCostSharePct)
          : null,
    },

    cacheEconomics: {
      cacheRead: totalCacheRead,
      cacheEfficiencyPct: cacheEfficiency,
      coldStartDetected,
      cacheReadToWriteRatio: cacheRwRatio,
      cacheEfficiencyAssessment:
        cacheTotalCreationAndRead > 0 ? computeCacheEfficiencyAssessment(cacheEfficiency) : null,
      cacheRatioAssessment:
        totalCacheCreation > 0 ? computeCacheRatioAssessment(cacheRwRatio) : null,
    },

    toolUsage: {
      counts: countsRecord,
      totalCalls: [...toolCounts.values()].reduce((sum, c) => sum + c, 0),
      successRates: toolSuccessRates,
      overallToolHealth,
    },

    subagentMetrics: saFromProcesses,

    subagentsList,

    errors: {
      errors,
      permissionDenials: {
        count: permissionDenials.length,
        denials: permissionDenials,
        affectedTools: [...new Set(permissionDenials.map((d) => d.tool))],
      },
    },

    gitActivity: {
      commitCount: gitCommits.length,
      commits: gitCommits,
      pushCount: gitPushCount,
      branchCreations: gitBranchCreations,
      linesAdded: linesAddedTotal,
      linesRemoved: linesRemovedTotal,
      linesChanged,
    },

    frictionSignals: {
      correctionCount,
      corrections,
      frictionRate,
    },

    thrashingSignals: {
      bashNearDuplicates,
      editReworkFiles,
      thrashingAssessment: computeThrashingAssessment(thrashingSignalCount),
    },

    conversationTree: {
      totalNodes: uuidToIdx.size,
      maxDepth,
      sidechainCount,
      branchPoints: branchPoints.size,
      branchDetails,
    },

    idleAnalysis: {
      idleThresholdSeconds: IDLE_THRESHOLD_SEC,
      idleGapCount: idleGaps.length,
      totalIdleSeconds: Math.round(totalIdle * 10) / 10,
      totalIdleHuman: formatDuration(Math.floor(totalIdle)),
      wallClockSeconds: Math.round(wallClock * 10) / 10,
      activeWorkingSeconds: Math.round(Math.max(activeTime, 0) * 10) / 10,
      activeWorkingHuman: formatDuration(Math.floor(Math.max(activeTime, 0))),
      idlePct,
      longestGaps: [...idleGaps].sort((a, b) => b.gapSeconds - a.gapSeconds).slice(0, 5),
      idleAssessment: computeIdleAssessment(idlePct),
    },

    modelSwitches: {
      count: modelSwitches.length,
      switches: modelSwitches,
      modelsUsed,
      switchPattern: detectSwitchPattern(modelSwitches),
    },

    workingDirectories: {
      uniqueDirectories: [...cwdSet],
      directoryCount: cwdSet.size,
      changes: cwdChanges,
      changeCount: cwdChanges.length,
      isMultiDirectory: cwdSet.size > 1,
    },

    testProgression: {
      snapshotCount: testSnapshots.length,
      snapshots: testSnapshots,
      trajectory,
      firstSnapshot: testSnapshots.length > 0 ? testSnapshots[0] : null,
      lastSnapshot: testSnapshots.length > 0 ? testSnapshots[testSnapshots.length - 1] : null,
    },

    startupOverhead: {
      messagesBeforeFirstWork: startupMessages,
      tokensBeforeFirstWork: startupTokens,
      pctOfTotal: startupPctOfTotal,
      overheadAssessment: computeOverheadAssessment(startupPctOfTotal),
    },

    tokenDensityTimeline: { quartiles },

    promptQuality: {
      firstMessageLengthChars: firstUserMessageLength,
      userMessageCount,
      correctionCount,
      frictionRate,
      assessment,
      note: promptNote,
    },

    thinkingBlocks: {
      count: thinkingCount,
      analyzedCount: thinkingAnalysis.length,
      signalSummary: signalTotals,
      notableBlocks: thinkingAnalysis.slice(0, 20),
    },

    keyEvents,

    messageTypes,

    fileReadRedundancy: {
      totalReads,
      uniqueFiles,
      readsPerUniqueFile,
      redundantFiles,
      redundancyAssessment: computeRedundancyAssessment(readsPerUniqueFile),
    },

    compaction: {
      count: session.compactionCount ?? 0,
      compactSummaryCount,
      note:
        (session.compactionCount ?? 0) > 0
          ? 'Session underwent compaction, which may have caused loss of earlier context. Check for repeated work after compaction events.'
          : 'No compaction occurred — session stayed within context limits.',
    },

    gitBranches: [...branches],

    skillsInvoked,

    bashCommands: {
      total: bashCmds.length,
      unique: new Set(bashCmds).size,
      repeated: Object.fromEntries(
        [
          ...bashCmds
            .reduce((acc, cmd) => acc.set(cmd, (acc.get(cmd) ?? 0) + 1), new Map<string, number>())
            .entries(),
        ]
          .filter(([, count]) => count > 1)
          .sort((a, b) => b[1] - a[1])
      ),
    },

    lifecycleTasks,

    userQuestions,

    outOfScopeFindings,

    agentTree: (() => {
      const uniqueAgents = new Map<string, AgentTreeNode>();
      for (const node of agentTreeNodes) {
        if (!uniqueAgents.has(node.agentId)) uniqueAgents.set(node.agentId, node);
      }
      return {
        agentCount: uniqueAgents.size,
        agents: [...uniqueAgents.values()],
        hasTeamMode: agentTreeNodes.some((n) => n.teamName),
        teamNames: [...new Set(agentTreeNodes.filter((n) => n.teamName).map((n) => n.teamName))],
      };
    })(),
  };

  return report;
}