oc-tweaks 0.7.1 → 0.8.2

package/dist/index.js

@@ -419,6 +419,2499 @@ var compactionPlugin = async () => {
     })
   };
 };
+// src/plugins/insights.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/insights/handler.ts
+import { mkdir as mkdir3, readdir as readdir2 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+
+// src/insights/aggregator.ts
+var OVERLAP_WINDOW_MS = 30 * 60 * 1000;
+var MAX_SESSION_SUMMARIES = 50;
+function incrementCounter(record, key, amount = 1) {
+  record[key] = (record[key] || 0) + amount;
+}
+function incrementEntries(target, source) {
+  for (const [key, count] of Object.entries(source)) {
+    if (count > 0) {
+      incrementCounter(target, key, count);
+    }
+  }
+}
+function toDateOnly(timestamp) {
+  if (!Number.isFinite(timestamp) || timestamp <= 0)
+    return "";
+  return new Date(timestamp).toISOString().slice(0, 10);
+}
+function calculateMedian(values) {
+  if (values.length === 0)
+    return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted[middle] ?? 0;
+}
+function buildSessionSummary(session, sessionFacets) {
+  return {
+    id: session.id,
+    date: toDateOnly(session.time_created),
+    summary: sessionFacets?.brief_summary || session.title,
+    goal: sessionFacets?.underlying_goal
+  };
+}
+function detectMultiClauding(sessions) {
+  const allSessionMessages = [];
+  for (const session of sessions) {
+    for (const timestamp of session.user_message_timestamps) {
+      if (Number.isFinite(timestamp)) {
+        allSessionMessages.push({ ts: timestamp, sessionId: session.id });
+      }
+    }
+  }
+  allSessionMessages.sort((a, b) => a.ts - b.ts);
+  const multiClaudeSessionPairs = new Set;
+  const messagesDuringMulticlaude = new Set;
+  let windowStart = 0;
+  const sessionLastIndex = new Map;
+  for (let i = 0;i < allSessionMessages.length; i += 1) {
+    const message = allSessionMessages[i];
+    while (windowStart < i && message.ts - allSessionMessages[windowStart].ts > OVERLAP_WINDOW_MS) {
+      const expiring = allSessionMessages[windowStart];
+      if (sessionLastIndex.get(expiring.sessionId) === windowStart) {
+        sessionLastIndex.delete(expiring.sessionId);
+      }
+      windowStart += 1;
+    }
+    const previousIndex = sessionLastIndex.get(message.sessionId);
+    if (previousIndex !== undefined) {
+      for (let j = previousIndex + 1;j < i; j += 1) {
+        const between = allSessionMessages[j];
+        if (between.sessionId !== message.sessionId) {
+          const pair = [message.sessionId, between.sessionId].sort().join(":");
+          multiClaudeSessionPairs.add(pair);
+          messagesDuringMulticlaude.add(`${allSessionMessages[previousIndex].ts}:${message.sessionId}`);
+          messagesDuringMulticlaude.add(`${between.ts}:${between.sessionId}`);
+          messagesDuringMulticlaude.add(`${message.ts}:${message.sessionId}`);
+          break;
+        }
+      }
+    }
+    sessionLastIndex.set(message.sessionId, i);
+  }
+  const sessionsWithOverlaps = new Set;
+  for (const pair of multiClaudeSessionPairs) {
+    const [first, second] = pair.split(":");
+    if (first)
+      sessionsWithOverlaps.add(first);
+    if (second)
+      sessionsWithOverlaps.add(second);
+  }
+  return {
+    overlap_events: multiClaudeSessionPairs.size,
+    sessions_involved: sessionsWithOverlaps.size,
+    user_messages_during: messagesDuringMulticlaude.size
+  };
+}
+function aggregateData(sessions, facets) {
+  const result = {
+    total_sessions: sessions.length,
+    sessions_with_facets: facets.size,
+    date_range: { start: "", end: "" },
+    total_messages: 0,
+    total_duration_hours: 0,
+    total_input_tokens: 0,
+    total_output_tokens: 0,
+    tool_counts: {},
+    languages: {},
+    git_commits: 0,
+    git_pushes: 0,
+    projects: {},
+    goal_categories: {},
+    outcomes: {},
+    satisfaction: {},
+    helpfulness: {},
+    session_types: {},
+    friction: {},
+    success: {},
+    session_summaries: [],
+    total_interruptions: 0,
+    total_tool_errors: 0,
+    tool_error_categories: {},
+    user_response_times: [],
+    median_response_time: 0,
+    avg_response_time: 0,
+    sessions_using_task_agent: 0,
+    sessions_using_mcp: 0,
+    sessions_using_web_search: 0,
+    sessions_using_web_fetch: 0,
+    total_lines_added: 0,
+    total_lines_removed: 0,
+    total_files_modified: 0,
+    days_active: 0,
+    messages_per_day: 0,
+    message_hours: [],
+    multi_clauding: {
+      overlap_events: 0,
+      sessions_involved: 0,
+      user_messages_during: 0
+    }
+  };
+  const sessionDates = [];
+  const allResponseTimes = [];
+  const allMessageHours = [];
+  for (const session of sessions) {
+    const sessionDate = toDateOnly(session.time_created);
+    if (sessionDate) {
+      sessionDates.push(sessionDate);
+    }
+    result.total_messages += session.total_messages;
+    result.total_duration_hours += session.duration_ms / (60 * 60 * 1000);
+    result.total_input_tokens += session.input_tokens;
+    result.total_output_tokens += session.output_tokens;
+    result.git_commits += session.git_commits;
+    result.git_pushes += session.git_pushes;
+    result.total_interruptions += session.user_interruptions;
+    result.total_tool_errors += session.tool_errors;
+    result.total_lines_added += session.lines_added;
+    result.total_lines_removed += session.lines_removed;
+    result.total_files_modified += session.files_modified;
+    incrementEntries(result.tool_counts, session.tool_counts);
+    incrementEntries(result.languages, session.languages);
+    incrementEntries(result.tool_error_categories, session.tool_error_categories);
+    incrementCounter(result.projects, session.project_id);
+    allResponseTimes.push(...session.user_response_times);
+    allMessageHours.push(...session.message_hours);
+    if (session.uses_task_agent)
+      result.sessions_using_task_agent += 1;
+    if (session.uses_mcp)
+      result.sessions_using_mcp += 1;
+    if (session.uses_web_search)
+      result.sessions_using_web_search += 1;
+    if (session.uses_web_fetch)
+      result.sessions_using_web_fetch += 1;
+    const sessionFacets = facets.get(session.id);
+    if (sessionFacets) {
+      incrementEntries(result.goal_categories, sessionFacets.goal_categories);
+      incrementCounter(result.outcomes, sessionFacets.outcome);
+      incrementEntries(result.satisfaction, sessionFacets.user_satisfaction_counts);
+      incrementCounter(result.helpfulness, sessionFacets.claude_helpfulness);
+      incrementCounter(result.session_types, sessionFacets.session_type);
+      incrementEntries(result.friction, sessionFacets.friction_counts);
+      if (sessionFacets.primary_success !== "none") {
+        incrementCounter(result.success, sessionFacets.primary_success);
+      }
+    }
+    if (result.session_summaries.length < MAX_SESSION_SUMMARIES) {
+      result.session_summaries.push(buildSessionSummary(session, sessionFacets));
+    }
+  }
+  sessionDates.sort();
+  result.date_range = {
+    start: sessionDates[0] || "",
+    end: sessionDates[sessionDates.length - 1] || ""
+  };
+  result.user_response_times = allResponseTimes;
+  result.median_response_time = calculateMedian(allResponseTimes);
+  result.avg_response_time = allResponseTimes.length > 0 ? allResponseTimes.reduce((sum, value) => sum + value, 0) / allResponseTimes.length : 0;
+  const uniqueDays = new Set(sessionDates);
+  result.days_active = uniqueDays.size;
+  result.messages_per_day = result.days_active > 0 ? result.total_messages / result.days_active : 0;
+  result.message_hours = allMessageHours;
+  result.multi_clauding = detectMultiClauding(sessions);
+  return result;
+}
+
+// src/insights/cache.ts
+import { Database } from "bun:sqlite";
+import { stat } from "node:fs/promises";
+var REPORT_TTL_MS = 24 * 60 * 60 * 1000;
+function getHomeDir() {
+  return Bun.env?.HOME ?? "";
+}
+function getDefaultDbPath() {
+  return `${getHomeDir()}/.local/share/opencode/opencode.db`;
+}
+function getFacetsDir() {
+  return `${getHomeDir()}/.local/share/opencode/insights/facets`;
+}
+function getReportDir() {
+  return `${getHomeDir()}/.local/share/opencode/insights`;
+}
+function getReportPath() {
+  return `${getReportDir()}/report.html`;
+}
+function isValidSessionFacets(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj))
+    return false;
+  const o = obj;
+  return typeof o.session_id === "string" && typeof o.underlying_goal === "string" && typeof o.outcome === "string" && typeof o.brief_summary === "string" && typeof o.claude_helpfulness === "string" && typeof o.session_type === "string" && typeof o.primary_success === "string" && typeof o.friction_detail === "string" && o.goal_categories !== null && typeof o.goal_categories === "object" && !Array.isArray(o.goal_categories) && o.user_satisfaction_counts !== null && typeof o.user_satisfaction_counts === "object" && !Array.isArray(o.user_satisfaction_counts) && o.friction_counts !== null && typeof o.friction_counts === "object" && !Array.isArray(o.friction_counts);
+}
+async function loadCachedFacets(sessionId) {
+  const facetPath = `${getFacetsDir()}/${sessionId}.json`;
+  try {
+    const file = Bun.file(facetPath);
+    if (!await file.exists())
+      return null;
+    const parsed = await file.json();
+    return isValidSessionFacets(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function saveFacets(facets) {
+  try {
+    await Bun.write(`${getFacetsDir()}/${facets.session_id}.json`, JSON.stringify(facets, null, 2));
+  } catch {
+    return;
+  }
+}
+async function getFileMtimeMs(path) {
+  try {
+    const info = await stat(path);
+    return Number.isFinite(info.mtimeMs) ? info.mtimeMs : null;
+  } catch {
+    return null;
+  }
+}
+function getLatestDbUpdate(dbPath) {
+  try {
+    const db = new Database(dbPath, { readonly: true });
+    const result = db.query("SELECT MAX(time_updated) AS max_time_updated FROM session").get();
+    db.close();
+    const value = result?.max_time_updated;
+    return typeof value === "number" ? value : value ? Number(value) : null;
+  } catch {
+    return null;
+  }
+}
+async function isReportFresh(dbPath) {
+  const reportPath = getReportPath();
+  const reportMtime = await getFileMtimeMs(reportPath);
+  if (reportMtime === null)
+    return false;
+  if (Date.now() - reportMtime > REPORT_TTL_MS)
+    return false;
+  const latestDbUpdate = getLatestDbUpdate(dbPath ?? getDefaultDbPath());
+  if (latestDbUpdate === null)
+    return false;
+  return latestDbUpdate <= reportMtime;
+}
+
+// src/insights/collector.ts
+import { Database as Database2 } from "bun:sqlite";
+
+// src/insights/constants.ts
+var EXTENSION_TO_LANGUAGE = {
+  ".ts": "TypeScript",
+  ".tsx": "TypeScript",
+  ".js": "JavaScript",
+  ".jsx": "JavaScript",
+  ".py": "Python",
+  ".rb": "Ruby",
+  ".go": "Go",
+  ".rs": "Rust",
+  ".java": "Java",
+  ".md": "Markdown",
+  ".json": "JSON",
+  ".yaml": "YAML",
+  ".yml": "YAML",
+  ".sh": "Shell",
+  ".css": "CSS",
+  ".html": "HTML"
+};
+var MAX_FACET_EXTRACTIONS = 50;
+var CONCURRENCY = 50;
+var MAX_SESSIONS = 200;
+
+// src/insights/collector.ts
+var REQUEST_INTERRUPTED_MARKER = "[Request interrupted by user";
+function getDefaultDbPath2() {
+  return `${Bun.env?.HOME ?? ""}/.local/share/opencode/opencode.db`;
+}
+function openDatabase(dbPath) {
+  return new Database2(dbPath, { readonly: true });
+}
+function getDbPath(dbPath) {
+  return dbPath || getDefaultDbPath2();
+}
+function resolveProjectId(db, project) {
+  if (project.includes("/")) {
+    const row = db.query("SELECT id FROM project WHERE worktree = ?").get(project);
+    if (row)
+      return row.id;
+  }
+  return project;
+}
+function mapSessionRow(row) {
+  return {
+    id: String(row.id),
+    project_id: String(row.project_id),
+    parent_id: row.parent_id ? String(row.parent_id) : undefined,
+    slug: String(row.slug),
+    directory: String(row.directory),
+    title: String(row.title),
+    version: String(row.version),
+    share_url: row.share_url ? String(row.share_url) : undefined,
+    summary_additions: toNumber(row.summary_additions),
+    summary_deletions: toNumber(row.summary_deletions),
+    summary_files: toNumber(row.summary_files),
+    summary_diffs: row.summary_diffs ? String(row.summary_diffs) : undefined,
+    time_created: toNumber(row.time_created),
+    time_updated: toNumber(row.time_updated),
+    time_compacting: row.time_compacting === null || row.time_compacting === undefined ? undefined : toNumber(row.time_compacting),
+    time_archived: row.time_archived === null || row.time_archived === undefined ? undefined : toNumber(row.time_archived),
+    workspace_id: row.workspace_id ? String(row.workspace_id) : undefined
+  };
+}
+function mapSessionStats(base, messages, parts) {
+  const stats = extractToolStats(messages, parts);
+  return {
+    ...base,
+    user_message_count: countHumanUserMessages(messages),
+    total_messages: messages.length,
+    duration_ms: Math.max(0, base.time_updated - base.time_created),
+    tool_counts: stats.toolCounts,
+    languages: stats.languages,
+    git_commits: stats.gitCommits,
+    git_pushes: stats.gitPushes,
+    input_tokens: stats.inputTokens,
+    output_tokens: stats.outputTokens,
+    user_interruptions: stats.userInterruptions,
+    tool_errors: stats.toolErrors,
+    tool_error_categories: stats.toolErrorCategories,
+    user_response_times: stats.userResponseTimes,
+    message_hours: stats.messageHours,
+    lines_added: stats.linesAdded,
+    lines_removed: stats.linesRemoved,
+    files_modified: stats.filesModified.size,
+    uses_task_agent: stats.usesTaskAgent,
+    uses_mcp: stats.usesMcp,
+    uses_web_search: stats.usesWebSearch,
+    uses_web_fetch: stats.usesWebFetch,
+    user_message_timestamps: stats.userMessageTimestamps
+  };
+}
+function toNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return 0;
+}
+function incrementCounter2(record, key, amount = 1) {
+  record[key] = (record[key] || 0) + amount;
+}
+function getLanguageFromPath(filePath) {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1)
+    return null;
+  const extension = filePath.slice(lastDot).toLowerCase();
+  return EXTENSION_TO_LANGUAGE[extension] ?? null;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getTimeValue(message) {
+  const created = message.time?.created;
+  if (typeof created === "number" && Number.isFinite(created))
+    return created;
+  return null;
+}
+function hasInterruptedContent(content) {
+  if (typeof content === "string")
+    return content.includes(REQUEST_INTERRUPTED_MARKER);
+  if (!Array.isArray(content))
+    return false;
+  return content.some((block) => isObject(block) && block.type === "text" && typeof block.text === "string" && block.text.includes(REQUEST_INTERRUPTED_MARKER));
+}
+function countHumanUserMessages(messages) {
+  return messages.filter((message) => message.role === "user").length;
+}
+function parseJsonBlob(value) {
+  return JSON.parse(String(value));
+}
+function queryMessages(db, sessionId) {
+  const rows = db.query("SELECT data FROM message WHERE session_id = ? ORDER BY time_created ASC").all(sessionId);
+  return rows.map((row) => parseJsonBlob(row.data));
+}
+function queryParts(db, sessionId) {
+  const rows = db.query("SELECT data FROM part WHERE session_id = ? ORDER BY id ASC").all(sessionId);
+  return rows.map((row) => parseJsonBlob(row.data));
+}
+function isRecoverableBlobError(error) {
+  if (error instanceof SyntaxError)
+    return true;
+  if (!(error instanceof Error))
+    return false;
+  const sqliteCode = isObject(error) && typeof error.code === "string" ? error.code : "";
+  if (sqliteCode === "SQLITE_CORRUPT")
+    return true;
+  const message = error.message.toLowerCase();
+  return message.includes("malformed") || message.includes("corrupt");
+}
+function queryMessagesSafely(db, sessionId) {
+  try {
+    return queryMessages(db, sessionId);
+  } catch (error) {
+    if (isRecoverableBlobError(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+function queryPartsSafely(db, sessionId) {
+  try {
+    return queryParts(db, sessionId);
+  } catch (error) {
+    if (isRecoverableBlobError(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+function detectToolError(output, explicitError) {
+  if (explicitError === true)
+    return true;
+  if (typeof explicitError === "string" && explicitError.trim().length > 0)
+    return true;
+  const outputText = typeof output === "string" ? output.toLowerCase() : "";
+  if (!outputText)
+    return false;
+  return outputText.includes("exit code") || outputText.includes("rejected") || outputText.includes("doesn't want") || outputText.includes("string to replace") || outputText.includes("no changes") || outputText.includes("modified since") || outputText.includes("exceeds maximum") || outputText.includes("too large") || outputText.includes("file not found") || outputText.includes("does not exist");
+}
+function categorizeToolError(output, explicitError) {
+  if (typeof explicitError === "string" && explicitError.trim().length > 0) {
+    output = explicitError;
+  }
+  if (typeof output !== "string")
+    return "Other";
+  const lowerContent = output.toLowerCase();
+  if (lowerContent.includes("exit code"))
+    return "Command Failed";
+  if (lowerContent.includes("rejected") || lowerContent.includes("doesn't want")) {
+    return "User Rejected";
+  }
+  if (lowerContent.includes("string to replace") || lowerContent.includes("no changes")) {
+    return "Edit Failed";
+  }
+  if (lowerContent.includes("modified since read"))
+    return "File Changed";
+  if (lowerContent.includes("exceeds maximum") || lowerContent.includes("too large")) {
+    return "File Too Large";
+  }
+  if (lowerContent.includes("file not found") || lowerContent.includes("does not exist")) {
+    return "File Not Found";
+  }
+  return "Other";
+}
+function countLines(text) {
+  if (!text)
+    return 0;
+  return text.split(`
+`).length;
+}
+function computeLineDiff(oldString, newString) {
+  const oldLines = oldString ? oldString.split(`
+`) : [];
+  const newLines = newString ? newString.split(`
+`) : [];
+  const lcs = Array.from({ length: oldLines.length + 1 }, () => Array.from({ length: newLines.length + 1 }, () => 0));
+  for (let i = oldLines.length - 1;i >= 0; i -= 1) {
+    for (let j = newLines.length - 1;j >= 0; j -= 1) {
+      if (oldLines[i] === newLines[j]) {
+        lcs[i][j] = lcs[i + 1][j + 1] + 1;
+      } else {
+        lcs[i][j] = Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+      }
+    }
+  }
+  const common = lcs[0][0];
+  return {
+    added: newLines.length - common,
+    removed: oldLines.length - common
+  };
+}
+async function collectSessions(options = {}) {
+  const dbPath = getDbPath(options.dbPath);
+  const db = openDatabase(dbPath);
+  try {
+    let sql = "SELECT * FROM session";
+    const conditions = [];
+    const params = [];
+    if (typeof options.days === "number" && Number.isFinite(options.days)) {
+      conditions.push("time_created > ?");
+      params.push(Date.now() - options.days * 86400000);
+    }
+    if (options.project) {
+      const projectId = resolveProjectId(db, options.project);
+      conditions.push("project_id = ?");
+      params.push(projectId);
+    }
+    conditions.push("title NOT LIKE ?");
+    params.push("%[insights-internal]%");
+    conditions.push("(parent_id IS NULL OR parent_id = '')");
+    if (conditions.length > 0) {
+      sql += ` WHERE ${conditions.join(" AND ")}`;
+    }
+    sql += " ORDER BY time_updated DESC";
+    const rows = db.query(sql).all(...params);
+    return rows.map((row) => {
+      const base = mapSessionRow(row);
+      const messages = queryMessagesSafely(db, base.id);
+      const parts = queryPartsSafely(db, base.id);
+      return mapSessionStats(base, messages, parts);
+    });
+  } finally {
+    db.close();
+  }
+}
+async function collectMessages(dbPath, sessionId) {
+  const db = openDatabase(dbPath);
+  try {
+    return queryMessages(db, sessionId);
+  } finally {
+    db.close();
+  }
+}
+async function collectParts(dbPath, sessionId) {
+  const db = openDatabase(dbPath);
+  try {
+    return queryPartsSafely(db, sessionId);
+  } finally {
+    db.close();
+  }
+}
+function extractToolStats(messages, parts) {
+  const toolCounts = {};
+  const languages = {};
+  let gitCommits = 0;
+  let gitPushes = 0;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let userInterruptions = 0;
+  const userResponseTimes = [];
+  let toolErrors = 0;
+  const toolErrorCategories = {};
+  let usesTaskAgent = false;
+  let usesMcp = false;
+  let usesWebSearch = false;
+  let usesWebFetch = false;
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  const filesModified = new Set;
+  const messageHours = [];
+  const userMessageTimestamps = [];
+  let lastAssistantTimestamp = null;
+  for (const message of messages) {
+    if (message.role === "assistant") {
+      inputTokens += toNumber(message.tokens?.input);
+      outputTokens += toNumber(message.tokens?.output);
+      const assistantTime = getTimeValue(message);
+      if (assistantTime !== null) {
+        lastAssistantTimestamp = assistantTime;
+      }
+      continue;
+    }
+    if (message.role !== "user")
+      continue;
+    const messageTime = getTimeValue(message);
+    if (messageTime !== null) {
+      const createdAt = new Date(messageTime);
+      messageHours.push(createdAt.getHours());
+      userMessageTimestamps.push(messageTime);
+      if (lastAssistantTimestamp !== null) {
+        const responseTimeSec = (messageTime - lastAssistantTimestamp) / 1000;
+        if (responseTimeSec > 2 && responseTimeSec < 3600) {
+          userResponseTimes.push(responseTimeSec);
+        }
+      }
+    }
+    if (hasInterruptedContent(message.content)) {
+      userInterruptions += 1;
+    }
+  }
+  for (const part of parts) {
+    if (part.type !== "tool" || !part.tool)
+      continue;
+    const toolName = part.tool;
+    incrementCounter2(toolCounts, toolName);
+    if (toolName === "Task" || toolName === "Agent")
+      usesTaskAgent = true;
+    if (toolName.startsWith("mcp__"))
+      usesMcp = true;
+    if (toolName === "WebSearch")
+      usesWebSearch = true;
+    if (toolName === "WebFetch")
+      usesWebFetch = true;
+    const input = isObject(part.state?.input) ? part.state?.input : {};
+    const filePath = typeof input.file_path === "string" ? input.file_path : "";
+    const language = filePath ? getLanguageFromPath(filePath) : null;
+    if (language) {
+      incrementCounter2(languages, language);
+    }
+    if ((toolName === "Edit" || toolName === "Write") && filePath) {
+      filesModified.add(filePath);
+    }
+    if (toolName === "Edit") {
+      const oldString = typeof input.old_string === "string" ? input.old_string : "";
+      const newString = typeof input.new_string === "string" ? input.new_string : "";
+      const diff = computeLineDiff(oldString, newString);
+      linesAdded += diff.added;
+      linesRemoved += diff.removed;
+    }
+    if (toolName === "Write") {
+      const writeContent = typeof input.content === "string" ? input.content : "";
+      linesAdded += countLines(writeContent);
+    }
+    const command = typeof input.command === "string" ? input.command : "";
+    if (command.includes("git commit"))
+      gitCommits += 1;
+    if (command.includes("git push"))
+      gitPushes += 1;
+    const output = part.state?.output;
+    const explicitError = part.state?.error;
+    if (detectToolError(output, explicitError)) {
+      toolErrors += 1;
+      incrementCounter2(toolErrorCategories, categorizeToolError(output, explicitError));
+    }
+  }
+  return {
+    toolCounts,
+    languages,
+    gitCommits,
+    gitPushes,
+    inputTokens,
+    outputTokens,
+    userInterruptions,
+    userResponseTimes,
+    toolErrors,
+    toolErrorCategories,
+    usesTaskAgent,
+    usesMcp,
+    usesWebSearch,
+    usesWebFetch,
+    linesAdded,
+    linesRemoved,
+    filesModified,
+    messageHours,
+    userMessageTimestamps
+  };
+}
+
+// src/insights/export.ts
+function getOpenCodeVersion() {
+  return process.env.OPENCODE_VERSION || "unknown";
+}
+function buildAtAGlanceSummary(insights) {
+  const atAGlance = insights.at_a_glance;
+  if (!atAGlance) {
+    return "_No insights generated_";
+  }
+  const sections = [
+    atAGlance.whats_working ? `**What's working:** ${atAGlance.whats_working} See _Impressive Things You Did_.` : "",
+    atAGlance.whats_hindering ? `**What's hindering you:** ${atAGlance.whats_hindering} See _Where Things Go Wrong_.` : "",
+    atAGlance.quick_wins ? `**Quick wins to try:** ${atAGlance.quick_wins} See _Features to Try_.` : "",
+    atAGlance.ambitious_workflows ? `**Ambitious workflows:** ${atAGlance.ambitious_workflows} See _On the Horizon_.` : ""
+  ].filter(Boolean);
+  return `## At a Glance
+
+${sections.join(`
+
+`)}`;
+}
+function buildStatsLine(data) {
+  const sessionLabel = data.total_sessions_scanned && data.total_sessions_scanned > data.total_sessions ? `${data.total_sessions_scanned.toLocaleString()} sessions total · ${data.total_sessions} analyzed` : `${data.total_sessions} sessions`;
+  return [
+    sessionLabel,
+    `${data.total_messages.toLocaleString()} messages`,
+    `${Math.round(data.total_duration_hours)}h`,
+    `${data.git_commits} commits`
+  ].join(" · ");
+}
+function buildExportData(data, insights, facets) {
+  const facetsSummary = {
+    total: facets.size,
+    goal_categories: {},
+    outcomes: {},
+    satisfaction: {},
+    friction: {}
+  };
+  for (const facet of facets.values()) {
+    for (const [category, count] of Object.entries(facet.goal_categories)) {
+      if (count > 0) {
+        facetsSummary.goal_categories[category] = (facetsSummary.goal_categories[category] || 0) + count;
+      }
+    }
+    facetsSummary.outcomes[facet.outcome] = (facetsSummary.outcomes[facet.outcome] || 0) + 1;
+    for (const [level, count] of Object.entries(facet.user_satisfaction_counts)) {
+      if (count > 0) {
+        facetsSummary.satisfaction[level] = (facetsSummary.satisfaction[level] || 0) + count;
+      }
+    }
+    for (const [type, count] of Object.entries(facet.friction_counts)) {
+      if (count > 0) {
+        facetsSummary.friction[type] = (facetsSummary.friction[type] || 0) + count;
+      }
+    }
+  }
+  return {
+    metadata: {
+      username: process.env.USER || "unknown",
+      generated_at: new Date().toISOString(),
+      opencode_version: getOpenCodeVersion(),
+      date_range: data.date_range,
+      session_count: data.total_sessions
+    },
+    aggregated_data: data,
+    insights,
+    facets_summary: facetsSummary
+  };
+}
+function buildPromptForCommand(insights, htmlPath, data, facetsDir) {
+  const reportUrl = `file://${htmlPath}`;
+  const header = `# OpenCode Insights
+
+${buildStatsLine(data)}
+${data.date_range.start} to ${data.date_range.end}
+`;
+  const userSummary = `${header}${buildAtAGlanceSummary(insights)}
+
+Your full shareable insights report is ready: ${reportUrl}`;
+  return `The user just ran /insights to generate a usage report analyzing their OpenCode sessions.
+
+Here is the full insights data:
+${JSON.stringify(insights, null, 2)}
+
+Report URL: ${reportUrl}
+HTML file: ${htmlPath}
+Facets directory: ${facetsDir}
+
+Here is what the user sees:
+${userSummary}
+
+Now output the following message exactly:
+
+<message>
+Your shareable insights report is ready:
+${reportUrl}
+
+Want to dig into any section or try one of the suggestions?
+</message>`;
+}
+
+// src/insights/prompts/facets-extraction.ts
+var FACET_EXTRACTION_PROMPT = `Analyze this OpenCode session and extract structured facets.
+
+CRITICAL GUIDELINES:
+
+1. **goal_categories**: Count ONLY what the USER explicitly asked for.
+   - DO NOT count the AI's autonomous codebase exploration
+   - DO NOT count work the AI decided to do on its own
+   - ONLY count when user says "can you...", "please...", "I need...", "let's..."
+
+2. **user_satisfaction_counts**: Base ONLY on explicit user signals.
+   - "Yay!", "great!", "perfect!" → happy
+   - "thanks", "looks good", "that works" → satisfied
+   - "ok, now let's..." (continuing without complaint) → likely_satisfied
+   - "that's not right", "try again" → dissatisfied
+   - "this is broken", "I give up" → frustrated
+
+3. **friction_counts**: Be specific about what went wrong.
+   - misunderstood_request: AI interpreted incorrectly
+   - wrong_approach: Right goal, wrong solution method
+   - buggy_code: Code didn't work correctly
+   - user_rejected_action: User said no/stop to a tool call
+   - excessive_changes: Over-engineered or changed too much
+
+4. If very short or just warmup, use warmup_minimal for goal_category
+
+SESSION:
+{transcript}
+
+RESPOND WITH ONLY A VALID JSON OBJECT matching this schema:
+{
+  "session_id": "Session identifier (use the id from session metadata)",
+  "underlying_goal": "What the user fundamentally wanted to achieve",
+  "goal_categories": {"category_name": count},
+  "outcome": "fully_achieved|mostly_achieved|partially_achieved|not_achieved|unclear_from_transcript",
+  "user_satisfaction_counts": {"level": count},
+  "claude_helpfulness": "unhelpful|slightly_helpful|moderately_helpful|very_helpful|essential",
+  "session_type": "single_task|multi_task|iterative_refinement|exploration|quick_question",
+  "friction_counts": {"friction_type": count},
+  "friction_detail": "One sentence describing friction or empty string",
+  "primary_success": "none|fast_accurate_search|correct_code_edits|good_explanations|proactive_help|multi_file_changes|good_debugging",
+  "brief_summary": "One sentence: what user wanted and whether they got it",
+  "user_instructions_to_claude": ["Instruction user gave the AI that they may want to reuse"]
+}`;
+
+// src/insights/facets.ts
+var MIN_USER_MESSAGES = 2;
+var MIN_DURATION_MS = 60000;
+var MAX_TRANSCRIPT_CHARS = 30000;
+var TRANSCRIPT_CHUNK_SIZE = 25000;
+var MAX_COMPRESSED_TRANSCRIPT_CHARS = 28000;
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toLimitedText(value, maxChars) {
+  if (typeof value !== "string")
+    return "";
+  const trimmed = value.replace(/\s+/g, " ").trim();
+  if (trimmed.length <= maxChars)
+    return trimmed;
+  return `${trimmed.slice(0, maxChars)}…`;
+}
+function safeStringify(value, maxChars) {
+  if (typeof value === "string")
+    return toLimitedText(value, maxChars);
+  try {
+    return toLimitedText(JSON.stringify(value), maxChars);
+  } catch {
+    return "";
+  }
+}
+function getMessageText(content, maxChars) {
+  if (typeof content === "string") {
+    return toLimitedText(content, maxChars);
+  }
+  if (!Array.isArray(content))
+    return "";
+  const pieces = [];
+  for (const block of content) {
+    if (!isObject2(block))
+      continue;
+    if (typeof block.text === "string") {
+      pieces.push(block.text);
+      continue;
+    }
+    if (typeof block.type === "string" && block.type === "tool_use" && typeof block.name === "string") {
+      pieces.push(`[ToolUse: ${block.name}]`);
+    }
+  }
+  return toLimitedText(pieces.join(`
+`), maxChars);
+}
+function formatTranscript(sessionId, messages, parts) {
+  const lines = [];
+  lines.push(`Session: ${sessionId}`);
+  lines.push(`Messages: ${messages.length}`);
+  lines.push(`Parts: ${parts.length}`);
+  lines.push("");
+  for (const message of messages) {
+    const role = typeof message?.role === "string" ? message.role : "unknown";
+    const text = getMessageText(message?.content, role === "assistant" ? 320 : 520);
+    if (text) {
+      lines.push(`[${role === "user" ? "User" : role === "assistant" ? "Assistant" : "Message"}] ${text}`);
+    }
+  }
+  if (parts.length > 0) {
+    lines.push("");
+    lines.push("[Tool Parts]");
+  }
+  for (const part of parts) {
+    if (part?.type !== "tool")
+      continue;
+    const toolName = typeof part.tool === "string" ? part.tool : "unknown";
+    const inputText = safeStringify(part.state?.input, 260);
+    const outputText = safeStringify(part.state?.output, 260);
+    const errorText = safeStringify(part.state?.error, 180);
+    lines.push(`[Tool: ${toolName}]`);
+    if (inputText)
+      lines.push(`  input: ${inputText}`);
+    if (outputText)
+      lines.push(`  output: ${outputText}`);
+    if (errorText)
+      lines.push(`  error: ${errorText}`);
+  }
+  return lines.join(`
+`);
+}
+function summarizeChunk(chunk, index, total) {
+  const lines = chunk.split(`
+`);
+  const userCount = lines.filter((line) => line.startsWith("[User]")).length;
+  const assistantCount = lines.filter((line) => line.startsWith("[Assistant]")).length;
+  const toolCount = lines.filter((line) => line.startsWith("[Tool:")).length;
+  const head = lines.slice(0, 24).join(`
+`);
+  const tail = lines.slice(-12).join(`
+`);
+  return [
+    `[Chunk ${index + 1}/${total}] users=${userCount} assistants=${assistantCount} tools=${toolCount}`,
+    "[Head]",
+    toLimitedText(head, 1500),
+    "[Tail]",
+    toLimitedText(tail, 1000)
+  ].join(`
+`);
+}
+function compressTranscriptIfNeeded(transcript) {
+  if (transcript.length <= MAX_TRANSCRIPT_CHARS)
+    return transcript;
+  const chunks = [];
+  for (let i = 0;i < transcript.length; i += TRANSCRIPT_CHUNK_SIZE) {
+    chunks.push(transcript.slice(i, i + TRANSCRIPT_CHUNK_SIZE));
+  }
+  const summarized = chunks.map((chunk, index) => summarizeChunk(chunk, index, chunks.length));
+  const combined = [
+    "[Long session transcript compressed for facet extraction]",
+    `Chunk count: ${chunks.length}`,
+    "",
+    summarized.join(`
+
+---
+
+`)
+  ].join(`
+`);
+  if (combined.length <= MAX_COMPRESSED_TRANSCRIPT_CHARS)
+    return combined;
+  return `${combined.slice(0, MAX_COMPRESSED_TRANSCRIPT_CHARS)}
+[truncated]`;
+}
+function getSessionItems(index, sessionId) {
+  if (index instanceof Map) {
+    const value = index.get(sessionId);
+    return Array.isArray(value) ? value : [];
+  }
+  if (isObject2(index)) {
+    const value = index[sessionId];
+    return Array.isArray(value) ? value : [];
+  }
+  return [];
+}
+function extractTextFromPromptResponse(response) {
+  const payload = isObject2(response) && "data" in response ? response.data : response;
+  if (!isObject2(payload))
+    return "";
+  const parts = payload.parts;
+  if (Array.isArray(parts)) {
+    const texts = parts.filter((part) => isObject2(part) && part.type === "text" && typeof part.text === "string").map((part) => String(part.text));
+    if (texts.length > 0)
+      return texts.join(`
+`);
+  }
+  if (typeof payload.text === "string")
+    return payload.text;
+  return "";
+}
+function getPromptSessionId(created) {
+  if (isObject2(created)) {
+    if (isObject2(created.data) && typeof created.data.id === "string")
+      return created.data.id;
+    if (typeof created.id === "string")
+      return created.id;
+  }
+  return null;
+}
+function isSubstantiveSession(meta) {
+  const userMessageCount = typeof meta?.user_message_count === "number" ? meta.user_message_count : 0;
+  const durationMs = typeof meta?.duration_ms === "number" ? meta.duration_ms : 0;
+  if (userMessageCount < MIN_USER_MESSAGES)
+    return false;
+  if (durationMs < MIN_DURATION_MS)
+    return false;
+  return true;
+}
+function isMinimalSession(facets) {
+  const categories = isObject2(facets?.goal_categories) ? facets.goal_categories : {};
+  const positive = Object.keys(categories).filter((key) => (categories[key] ?? 0) > 0);
+  return positive.length === 1 && positive[0] === "warmup_minimal";
+}
+async function extractFacetsFromAPI(client, sessionId, messages, parts) {
+  try {
+    const transcript = compressTranscriptIfNeeded(formatTranscript(sessionId, messages, parts));
+    const promptText = FACET_EXTRACTION_PROMPT.replace("{transcript}", transcript);
+    let promptSessionId = sessionId;
+    if (client?.session?.create) {
+      const created = await client.session.create({
+        body: {
+          title: `[insights-internal] facets ${sessionId}`
+        }
+      });
+      promptSessionId = getPromptSessionId(created) ?? promptSessionId;
+    }
+    const response = await client?.session?.prompt({
+      path: { id: promptSessionId },
+      body: {
+        parts: [{ type: "text", text: promptText }]
+      }
+    });
+    const text = extractTextFromPromptResponse(response);
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+      return null;
+    const parsed = JSON.parse(jsonMatch[0]);
+    if (!isValidSessionFacets(parsed))
+      return null;
+    const facets = {
+      ...parsed,
+      session_id: sessionId
+    };
+    await saveFacets(facets);
+    return facets;
+  } catch {
+    return null;
+  }
+}
+async function extractAllFacets(client, sessions, messages, parts, cachedFacets) {
+  const facets = new Map;
+  for (const [sessionId, cached] of cachedFacets ?? new Map) {
+    facets.set(sessionId, cached);
+  }
+  const substantiveSessions = sessions.filter(isSubstantiveSession);
+  const toExtract = [];
+  const cacheLookup = await Promise.all(substantiveSessions.map(async (meta) => {
+    const sessionId = meta.id;
+    if (facets.has(sessionId)) {
+      return { sessionId, cached: facets.get(sessionId) ?? null };
+    }
+    const cached = await loadCachedFacets(sessionId);
+    return { sessionId, cached };
+  }));
+  for (const item of cacheLookup) {
+    if (item.cached) {
+      facets.set(item.sessionId, item.cached);
+      continue;
+    }
+    if (toExtract.length < MAX_FACET_EXTRACTIONS) {
+      toExtract.push(item.sessionId);
+    }
+  }
+  for (let i = 0;i < toExtract.length; i += CONCURRENCY) {
+    const batch = toExtract.slice(i, i + CONCURRENCY);
+    const results = await Promise.all(batch.map(async (sessionId) => {
+      const sessionMessages = getSessionItems(messages, sessionId);
+      const sessionParts = getSessionItems(parts, sessionId);
+      const extracted = await extractFacetsFromAPI(client, sessionId, sessionMessages, sessionParts);
+      return { sessionId, extracted };
+    }));
+    for (const item of results) {
+      if (item.extracted) {
+        facets.set(item.sessionId, item.extracted);
+      }
+    }
+  }
+  return facets;
+}
+
+// src/insights/prompts/at-a-glance.ts
+var AT_A_GLANCE_PROMPT = `You're writing an "At a Glance" summary for an OpenCode usage insights report. The goal is to help users understand their usage and improve how they work with OpenCode, especially as models improve.
+
+Use this 4-part structure:
+
+1. **What's working** - What is the user's unique style of interacting with OpenCode and what are some impactful things they've done? Include one or two details, but keep it high level. Don't be fluffy or overly complimentary. Don't focus on tool calls.
+
+2. **What's hindering you** - Split into (a) the AI's fault (misunderstandings, wrong approaches, bugs) and (b) user-side friction (not providing enough context, environment issues - ideally more general than just one project). Be honest but constructive.
+
+3. **Quick wins to try** - Specific features they could try from the examples below, or a compelling workflow technique. Avoid generic advice like "ask the AI to confirm before actions" or "type more context upfront".
+
+4. **Ambitious workflows for better models** - As models improve over the next 3-6 months, what should they prepare for? What workflows that seem impossible now will become possible? Draw from the on_the_horizon section below.
+
+Keep each section to 2-3 not-too-long sentences. Don't overwhelm the user. Don't mention specific numerical stats. Use a coaching tone. Use second person "you".
+
+RESPOND WITH ONLY A VALID JSON OBJECT:
+{
+  "whats_working": "2-3 sentences about unique style and impactful work",
+  "whats_hindering": "2-3 sentences split between Claude's fault and user-side friction",
+  "quick_wins": "2-3 sentences with specific, compelling features or techniques to try",
+  "ambitious_workflows": "2-3 sentences about preparing for more capable models"
+}
+
+SESSION DATA:
+{fullContext}
+
+## Project Areas (what user works on)
+{projectAreasText}
+
+## Big Wins (impressive accomplishments)
+{bigWinsText}
+
+## Friction Categories (where things go wrong)
+{frictionText}
+
+## Features to Try
+{featuresText}
+
+## Usage Patterns to Adopt
+{patternsText}
+
+## On the Horizon (ambitious workflows for better models)
+{horizonText}`;
+
+// src/insights/prompts/sections.ts
+var INSIGHT_SECTIONS = [
+  {
+    name: "project_areas",
+    prompt: `Analyze this OpenCode usage data and identify project areas.
+
+RESPOND WITH ONLY A VALID JSON OBJECT:
+{
+  "areas": [
+    {"name": "Area name", "session_count": N, "description": "2-3 sentences about what was worked on and how OpenCode was used."}
+  ]
+}
+
+Include 4-5 areas. Skip internal tool operations.`
+  },
+  {
+    name: "interaction_style",
+    prompt: `Analyze this OpenCode usage data and describe the user's interaction style.
+
+RESPOND WITH ONLY A VALID JSON OBJECT:
+{
+  "narrative": "2-3 paragraphs analyzing HOW the user interacts with OpenCode. Use second person 'you'. Describe patterns: iterate quickly vs detailed upfront specs? Interrupt often or let the AI run? Include specific examples. Use **bold** for key insights.",
+  "key_pattern": "One sentence summary of most distinctive interaction style"
+}`
+  },
+  {
+    name: "what_works",
+    prompt: `Analyze this OpenCode usage data and identify what's working well for this user. Use second person ("you").
+
+RESPOND WITH ONLY A VALID JSON OBJECT:
+{
+  "intro": "1 sentence of context",
+  "impressive_workflows": [
+    {"title": "Short title (3-6 words)", "description": "2-3 sentences describing the impressive workflow or approach. Use 'you' not 'the user'."}
+  ]
+}
+
+Include 3 impressive workflows.`
+  },
+  {
+    name: "friction_analysis",
+    prompt: `Analyze this OpenCode usage data and identify friction points for this user. Use second person ("you").
+
+RESPOND WITH ONLY A VALID JSON OBJECT:
+{
+  "intro": "1 sentence summarizing friction patterns",
+  "categories": [
+    {"category": "Concrete category name", "description": "1-2 sentences explaining this category and what could be done differently. Use 'you' not 'the user'.", "examples": ["Specific example with consequence", "Another example"]}
+  ]
+}
+
+Include 3 friction categories with 2 examples each.`
+  },
+  {
+    name: "suggestions",
+    prompt: `Analyze this OpenCode usage data and suggest improvements.
+
+## FEATURES REFERENCE (pick from these for features_to_try):
+1. **MCP Servers**: Connect OpenCode to external tools, databases, and APIs via Model Context Protocol.
+   - How to use: Add MCP server config to your OpenCode settings
+   - Good for: database queries, Slack integration, GitHub issue lookup, connecting to internal APIs
+
+2. **Custom Commands**: Reusable prompts you define as markdown files that run with a single /command.
+   - How to use: Create a command file in your OpenCode commands directory with instructions, then type \`/command-name\` to run it.
+   - Good for: repetitive workflows - /commit, /review, /test, /deploy, /pr, or complex multi-step workflows
+
+3. **Hooks**: Shell commands that auto-run at specific lifecycle events.
+   - How to use: Add hook config to your OpenCode settings under the "hooks" key.
+   - Good for: auto-formatting code, running type checks, enforcing conventions
+
+4. **Non-interactive Mode**: Run OpenCode from scripts and CI/CD without an interactive session.
+   - Good for: CI/CD integration, batch code fixes, automated reviews
+
+5. **Task Agents**: OpenCode spawns focused sub-agents for complex exploration or parallel work.
+   - How to use: The AI auto-invokes when helpful, or ask "use an agent to explore X"
+   - Good for: codebase exploration, understanding complex systems
+
+RESPOND WITH ONLY A VALID JSON OBJECT:
+{
+  "claude_md_additions": [
+    {"addition": "A specific line or block to add to your project instruction file (AGENTS.md) based on workflow patterns. E.g., 'Always run tests after modifying auth-related files'", "why": "1 sentence explaining why this would help based on actual sessions", "prompt_scaffold": "Instructions for where to add this. E.g., 'Add under ## Testing section'"}
+  ],
+  "features_to_try": [
+    {"feature": "Feature name from FEATURES REFERENCE above", "one_liner": "What it does", "why_for_you": "Why this would help YOU based on your sessions", "example_code": "Actual command or config to copy"}
+  ],
+  "usage_patterns": [
+    {"title": "Short title", "suggestion": "1-2 sentence summary", "detail": "3-4 sentences explaining how this applies to YOUR work", "copyable_prompt": "A specific prompt to copy and try"}
+  ]
+}
+
+IMPORTANT for claude_md_additions: PRIORITIZE instructions that appear MULTIPLE TIMES in the user data. If the user told the AI the same thing in 2+ sessions (e.g., 'always run tests', 'use TypeScript'), that's a PRIME candidate - they shouldn't have to repeat themselves.
+
+IMPORTANT for features_to_try: Pick 2-3 from the FEATURES REFERENCE above. Include 2-3 items for each category.`
+  },
+  {
+    name: "on_the_horizon",
+    prompt: `Analyze this OpenCode usage data and identify future opportunities.
+
+RESPOND WITH ONLY A VALID JSON OBJECT:
+{
+  "intro": "1 sentence about evolving AI-assisted development",
+  "opportunities": [
+    {"title": "Short title (4-8 words)", "whats_possible": "2-3 ambitious sentences about autonomous workflows", "how_to_try": "1-2 sentences mentioning relevant tooling", "copyable_prompt": "Detailed prompt to try"}
+  ]
+}
+
+Include 3 opportunities. Think BIG - autonomous workflows, parallel agents, iterating against tests.`
+  },
+  {
+    name: "fun_ending",
+    prompt: `Analyze this OpenCode usage data and find a memorable moment.
+
+RESPOND WITH ONLY A VALID JSON OBJECT:
+{
+  "headline": "A memorable QUALITATIVE moment from the transcripts - not a statistic. Something human, funny, or surprising.",
+  "detail": "Brief context about when/where this happened"
+}
+
+Find something genuinely interesting or amusing from the session summaries.`
+  }
+];
+
+// src/insights/generator.ts
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getPromptSessionId2(created) {
+  if (isObject3(created)) {
+    if (isObject3(created.data) && typeof created.data.id === "string")
+      return created.data.id;
+    if (typeof created.id === "string")
+      return created.id;
+  }
+  return null;
+}
+function extractTextFromPromptResponse2(response) {
+  const payload = isObject3(response) && "data" in response ? response.data : response;
+  if (!isObject3(payload))
+    return "";
+  const parts = payload.parts;
+  if (Array.isArray(parts)) {
+    const texts = parts.filter((part) => isObject3(part) && part.type === "text" && typeof part.text === "string").map((part) => String(part.text));
+    if (texts.length > 0)
+      return texts.join(`
+`);
+  }
+  if (typeof payload.text === "string")
+    return payload.text;
+  return "";
+}
+function parseJsonObjectFromText(text) {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch)
+    return null;
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    return isObject3(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function topCounts(counts, limit) {
+  return Object.entries(counts || {}).filter(([, count]) => Number.isFinite(count) && count > 0).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([name, count]) => ({ name, count }));
+}
+function buildDataContext(data) {
+  return {
+    sessions: data.total_sessions_scanned ?? data.total_sessions,
+    analyzed: data.total_sessions,
+    date_range: data.date_range,
+    messages: data.total_messages,
+    hours: Number(data.total_duration_hours.toFixed(2)),
+    commits: data.git_commits,
+    top_tools: topCounts(data.tool_counts, 8),
+    top_goals: topCounts(data.goal_categories, 8),
+    outcomes: data.outcomes,
+    satisfaction: data.satisfaction,
+    friction: data.friction,
+    success: data.success,
+    languages: topCounts(data.languages, 8)
+  };
+}
+function buildFullContext(data, facets) {
+  const dataContext = buildDataContext(data);
+  const facetItems = Array.from(facets.values());
+  const sessionSummaries = facetItems.slice(0, 50).map((facet) => ({
+    session_id: facet.session_id,
+    brief_summary: facet.brief_summary,
+    outcome: facet.outcome,
+    claude_helpfulness: facet.claude_helpfulness
+  }));
+  const frictionDetails = facetItems.map((facet) => ({
+    session_id: facet.session_id,
+    friction_detail: facet.friction_detail
+  })).filter((item) => item.friction_detail && item.friction_detail.trim().length > 0).slice(0, 20);
+  const userInstructions = facetItems.flatMap((facet) => (facet.user_instructions_to_claude || []).map((instruction) => ({
+    session_id: facet.session_id,
+    instruction
+  }))).filter((item) => item.instruction && item.instruction.trim().length > 0).slice(0, 15);
+  return JSON.stringify({
+    data_context: dataContext,
+    session_summaries: sessionSummaries,
+    friction_details: frictionDetails,
+    user_instructions: userInstructions
+  }, null, 2);
+}
+function stringifyForPrompt(value) {
+  if (value === null || value === undefined)
+    return "No section output available";
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function pickSuggestionsField(suggestions, key) {
+  if (!isObject3(suggestions))
+    return null;
+  return suggestions[key] ?? null;
+}
+async function promptWithInternalSession(client, title, promptText) {
+  let promptSessionId = `insights-internal-${Date.now()}`;
+  if (client?.session?.create) {
+    const created = await client.session.create({
+      body: {
+        title
+      }
+    });
+    promptSessionId = getPromptSessionId2(created) ?? promptSessionId;
+  }
+  const response = await client?.session?.prompt({
+    path: { id: promptSessionId },
+    body: {
+      parts: [{ type: "text", text: promptText }]
+    }
+  });
+  return extractTextFromPromptResponse2(response);
+}
+async function generateInsightFromPrompt(client, sectionName, promptText) {
+  try {
+    const title = `[insights-internal] section ${sectionName}`;
+    const responseText = await promptWithInternalSession(client, title, promptText);
+    return parseJsonObjectFromText(responseText);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    console.warn(`[insights] section ${sectionName} failed: ${reason}`);
+    return null;
+  }
+}
+async function generateSectionInsight(client, section, fullContext) {
+  const promptText = `${section.prompt}
+
+SESSION DATA (JSON):
+${fullContext}`;
+  return generateInsightFromPrompt(client, section.name, promptText);
+}
+async function generateParallelInsights(client, data, facets, onProgress) {
+  const dataContext = buildDataContext(data);
+  const fullContext = buildFullContext(data, facets);
+  const regularSections = INSIGHT_SECTIONS.filter((section) => section.name !== "at_a_glance");
+  onProgress?.({ stage: "sections-start", completed: 0, total: regularSections.length + 1 });
+  const sectionResults = await Promise.all(regularSections.map(async (section) => ({
+    name: section.name,
+    insight: await generateSectionInsight(client, section, fullContext)
+  })));
+  const insights = {};
+  const sectionMap = {};
+  let completedSections = 0;
+  for (const { name, insight } of sectionResults) {
+    sectionMap[name] = insight;
+    insights[name] = insight;
+    completedSections += 1;
+    onProgress?.({
+      stage: "section-complete",
+      section: name,
+      completed: completedSections,
+      total: regularSections.length + 1
+    });
+  }
+  const atAGlancePrompt = AT_A_GLANCE_PROMPT.replace("{fullContext}", `${fullContext}
+
+Data Context Snapshot:
+${stringifyForPrompt(dataContext)}`).replace("{projectAreasText}", stringifyForPrompt(sectionMap.project_areas)).replace("{bigWinsText}", stringifyForPrompt(sectionMap.what_works)).replace("{frictionText}", stringifyForPrompt(sectionMap.friction_analysis)).replace("{featuresText}", stringifyForPrompt(pickSuggestionsField(sectionMap.suggestions, "features_to_try"))).replace("{patternsText}", stringifyForPrompt(pickSuggestionsField(sectionMap.suggestions, "usage_patterns"))).replace("{horizonText}", stringifyForPrompt(sectionMap.on_the_horizon));
+  const atAGlance = await generateInsightFromPrompt(client, "at_a_glance", atAGlancePrompt);
+  insights.at_a_glance = atAGlance;
+  onProgress?.({
+    stage: "section-complete",
+    section: "at_a_glance",
+    completed: regularSections.length + 1,
+    total: regularSections.length + 1
+  });
+  return insights;
+}
+
+// src/insights/renderer.ts
+function escapeHtml(text) {
+  if (!text)
+    return "";
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function escapeHtmlWithBold(text) {
+  const escaped = escapeHtml(text);
+  return escaped.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+}
+var SATISFACTION_ORDER = [
+  "frustrated",
+  "dissatisfied",
+  "likely_satisfied",
+  "satisfied",
+  "happy",
+  "unsure",
+  "neutral",
+  "delighted"
+];
+var OUTCOME_ORDER = [
+  "not_achieved",
+  "partially_achieved",
+  "mostly_achieved",
+  "fully_achieved",
+  "unclear_from_transcript"
+];
+var LABEL_MAP = {
+  single_task: "Single Task",
+  multi_task: "Multi Task",
+  iterative_refinement: "Iterative Refinement",
+  exploration: "Exploration",
+  quick_question: "Quick Question"
+};
+function generateBarChart(data, color, maxItems = 6, fixedOrder) {
+  let entries;
+  if (fixedOrder) {
+    entries = fixedOrder.filter((key) => (key in data) && (data[key] ?? 0) > 0).map((key) => [key, data[key] ?? 0]);
+  } else {
+    entries = Object.entries(data || {}).sort((a, b) => b[1] - a[1]).slice(0, maxItems);
+  }
+  if (entries.length === 0)
+    return '<p class="empty">No data</p>';
+  const maxVal = Math.max(...entries.map((e) => e[1]));
+  return entries.map(([label, count]) => {
+    const pct = count / maxVal * 100;
+    const cleanLabel = LABEL_MAP[label] || label.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    return `<div class="bar-row">
+        <div class="bar-label">${escapeHtml(cleanLabel)}</div>
+        <div class="bar-track"><div class="bar-fill" style="width:${pct}%;background:${color}"></div></div>
+        <div class="bar-value">${count}</div>
+      </div>`;
+  }).join(`
+`);
+}
+function generateResponseTimeHistogram(times) {
+  if (!times || times.length === 0)
+    return '<p class="empty">No response time data</p>';
+  const buckets = {
+    "2-10s": 0,
+    "10-30s": 0,
+    "30s-1m": 0,
+    "1-2m": 0,
+    "2-5m": 0,
+    "5-15m": 0,
+    ">15m": 0
+  };
+  for (const t of times) {
+    if (t < 10)
+      buckets["2-10s"] = (buckets["2-10s"] ?? 0) + 1;
+    else if (t < 30)
+      buckets["10-30s"] = (buckets["10-30s"] ?? 0) + 1;
+    else if (t < 60)
+      buckets["30s-1m"] = (buckets["30s-1m"] ?? 0) + 1;
+    else if (t < 120)
+      buckets["1-2m"] = (buckets["1-2m"] ?? 0) + 1;
+    else if (t < 300)
+      buckets["2-5m"] = (buckets["2-5m"] ?? 0) + 1;
+    else if (t < 900)
+      buckets["5-15m"] = (buckets["5-15m"] ?? 0) + 1;
+    else
+      buckets[">15m"] = (buckets[">15m"] ?? 0) + 1;
+  }
+  const maxVal = Math.max(...Object.values(buckets));
+  if (maxVal === 0)
+    return '<p class="empty">No response time data</p>';
+  return Object.entries(buckets).map(([label, count]) => {
+    const pct = count / maxVal * 100;
+    return `<div class="bar-row">
+        <div class="bar-label">${label}</div>
+        <div class="bar-track"><div class="bar-fill" style="width:${pct}%;background:#6366f1"></div></div>
+        <div class="bar-value">${count}</div>
+      </div>`;
+  }).join(`
+`);
+}
+function generateTimeOfDayChart(messageHours) {
+  if (!messageHours || messageHours.length === 0)
+    return '<p class="empty">No time data</p>';
+  const periods = [
+    { label: "Morning (6-12)", range: [6, 7, 8, 9, 10, 11] },
+    { label: "Afternoon (12-18)", range: [12, 13, 14, 15, 16, 17] },
+    { label: "Evening (18-24)", range: [18, 19, 20, 21, 22, 23] },
+    { label: "Night (0-6)", range: [0, 1, 2, 3, 4, 5] }
+  ];
+  const hourCounts = {};
+  for (const h of messageHours) {
+    hourCounts[h] = (hourCounts[h] || 0) + 1;
+  }
+  const periodCounts = periods.map((p) => ({
+    label: p.label,
+    count: p.range.reduce((sum, h) => sum + (hourCounts[h] || 0), 0)
+  }));
+  const maxVal = Math.max(...periodCounts.map((p) => p.count)) || 1;
+  const barsHtml = periodCounts.map((p) => `
+      <div class="bar-row">
+        <div class="bar-label">${p.label}</div>
+        <div class="bar-track"><div class="bar-fill" style="width:${p.count / maxVal * 100}%;background:#8b5cf6"></div></div>
+        <div class="bar-value">${p.count}</div>
+      </div>`).join(`
+`);
+  return `<div id="hour-histogram">${barsHtml}</div>`;
+}
+function getHourCountsJson(messageHours) {
+  const hourCounts = {};
+  if (messageHours) {
+    for (const h of messageHours) {
+      hourCounts[h] = (hourCounts[h] || 0) + 1;
+    }
+  }
+  return JSON.stringify(hourCounts);
+}
+function generateHtmlReport(data, insights) {
+  const markdownToHtml = (md) => {
+    if (!md)
+      return "";
+    return md.split(`
+
+`).map((p) => {
+      let html = escapeHtml(p);
+      html = html.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+      html = html.replace(/^- /gm, "• ");
+      html = html.replace(/\n/g, "<br>");
+      return `<p>${html}</p>`;
+    }).join(`
+`);
+  };
+  const atAGlance = insights.at_a_glance;
+  const atAGlanceHtml = atAGlance ? `
+    <div id="section-glance" class="at-a-glance">
+      <div class="glance-title">At a Glance</div>
+      <div class="glance-sections">
+        ${atAGlance.whats_working ? `<div class="glance-section"><strong>What's working:</strong> ${escapeHtmlWithBold(atAGlance.whats_working)} <a href="#section-wins" class="see-more">Impressive Things You Did →</a></div>` : ""}
+        ${atAGlance.whats_hindering ? `<div class="glance-section"><strong>What's hindering you:</strong> ${escapeHtmlWithBold(atAGlance.whats_hindering)} <a href="#section-friction" class="see-more">Where Things Go Wrong →</a></div>` : ""}
+        ${atAGlance.quick_wins ? `<div class="glance-section"><strong>Quick wins to try:</strong> ${escapeHtmlWithBold(atAGlance.quick_wins)} <a href="#section-features" class="see-more">Features to Try →</a></div>` : ""}
+        ${atAGlance.ambitious_workflows ? `<div class="glance-section"><strong>Ambitious workflows:</strong> ${escapeHtmlWithBold(atAGlance.ambitious_workflows)} <a href="#section-horizon" class="see-more">On the Horizon →</a></div>` : ""}
+      </div>
+    </div>
+    ` : `<div id="section-glance" style="display:none;"></div>`;
+  const projectAreas = insights.project_areas?.areas || [];
+  const projectAreasHtml = projectAreas.length > 0 ? `
+    <h2 id="section-projects">What You Work On</h2>
+    <div class="project-areas">
+      ${projectAreas.map((area) => `
+        <div class="project-area">
+          <div class="area-header">
+            <span class="area-name">${escapeHtml(area.name)}</span>
+            <span class="area-count">~${area.session_count} sessions</span>
+          </div>
+          <div class="area-desc">${escapeHtml(area.description)}</div>
+        </div>
+      `).join("")}
+    </div>
+    ` : `<h2 id="section-projects" style="display:none;">What You Work On</h2>`;
+  const interactionStyle = insights.interaction_style;
+  const interactionHtml = interactionStyle?.narrative ? `
+    <h2 id="section-style">How You Use OpenCode</h2>
+    <div class="narrative">
+      ${markdownToHtml(interactionStyle.narrative)}
+      ${interactionStyle.key_pattern ? `<div class="key-insight"><strong>Key pattern:</strong> ${escapeHtml(interactionStyle.key_pattern)}</div>` : ""}
+    </div>
+    ` : `<h2 id="section-style" style="display:none;">How You Use OpenCode</h2>`;
+  const whatWorks = insights.what_works;
+  const whatWorksHtml = whatWorks?.impressive_workflows && whatWorks.impressive_workflows.length > 0 ? `
+    <h2 id="section-wins">Impressive Things You Did</h2>
+    ${whatWorks.intro ? `<p class="section-intro">${escapeHtml(whatWorks.intro)}</p>` : ""}
+    <div class="big-wins">
+      ${whatWorks.impressive_workflows.map((wf) => `
+        <div class="big-win">
+          <div class="big-win-title">${escapeHtml(wf.title || "")}</div>
+          <div class="big-win-desc">${escapeHtml(wf.description || "")}</div>
+        </div>
+      `).join("")}
+    </div>
+    ` : `<h2 id="section-wins" style="display:none;">Impressive Things You Did</h2>`;
+  const frictionAnalysis = insights.friction_analysis;
+  const frictionHtml = frictionAnalysis?.categories && frictionAnalysis.categories.length > 0 ? `
+    <h2 id="section-friction">Where Things Go Wrong</h2>
+    ${frictionAnalysis.intro ? `<p class="section-intro">${escapeHtml(frictionAnalysis.intro)}</p>` : ""}
+    <div class="friction-categories">
+      ${frictionAnalysis.categories.map((cat) => `
+        <div class="friction-category">
+          <div class="friction-title">${escapeHtml(cat.category || "")}</div>
+          <div class="friction-desc">${escapeHtml(cat.description || "")}</div>
+          ${cat.examples ? `<ul class="friction-examples">${cat.examples.map((ex) => `<li>${escapeHtml(ex)}</li>`).join("")}</ul>` : ""}
+        </div>
+      `).join("")}
+    </div>
+    ` : `<h2 id="section-friction" style="display:none;">Where Things Go Wrong</h2>`;
+  const suggestions = insights.suggestions;
+  const suggestionsHtml = suggestions ? `
+    ${suggestions.claude_md_additions && suggestions.claude_md_additions.length > 0 || suggestions.features_to_try && suggestions.features_to_try.length > 0 ? `<h2 id="section-features">Features to Try</h2>` : `<h2 id="section-features" style="display:none;">Features to Try</h2>`}
+    ${suggestions.claude_md_additions && suggestions.claude_md_additions.length > 0 ? `
+    <div class="claude-md-section">
+      <h3>Suggested AGENTS.md Additions</h3>
+      <p style="font-size: 12px; color: var(--text-muted); margin-bottom: 12px;">Just copy this into OpenCode to add it to your AGENTS.md.</p>
+      <div class="claude-md-actions">
+        <button class="copy-all-btn" onclick="copyAllCheckedAgentsMd()">Copy All Checked</button>
+      </div>
+      ${suggestions.claude_md_additions.map((add, i) => `
+        <div class="claude-md-item">
+          <input type="checkbox" id="cmd-${i}" class="cmd-checkbox" checked data-text="${escapeHtml(add.prompt_scaffold || add.where || "Add to AGENTS.md")}
+
+${escapeHtml(add.addition)}">
+          <label for="cmd-${i}">
+            <code class="cmd-code">${escapeHtml(add.addition)}</code>
+            <button class="copy-btn" onclick="copyCmdItem(${i})">Copy</button>
+          </label>
+          <div class="cmd-why">${escapeHtml(add.why)}</div>
+        </div>
+      `).join("")}
+    </div>
+    ` : ""}
+    ${suggestions.features_to_try && suggestions.features_to_try.length > 0 ? `
+    <p style="font-size: 13px; color: var(--text-muted); margin-bottom: 12px;">Just copy this into OpenCode and it'll set it up for you.</p>
+    <div class="features-section">
+      ${suggestions.features_to_try.map((feat) => `
+        <div class="feature-card">
+          <div class="feature-title">${escapeHtml(feat.feature || "")}</div>
+          <div class="feature-oneliner">${escapeHtml(feat.one_liner || "")}</div>
+          <div class="feature-why"><strong>Why for you:</strong> ${escapeHtml(feat.why_for_you || "")}</div>
+          ${feat.example_code ? `
+          <div class="feature-examples">
+            <div class="feature-example">
+              <div class="example-code-row">
+                <code class="example-code">${escapeHtml(feat.example_code)}</code>
+                <button class="copy-btn" onclick="copyText(this)">Copy</button>
+              </div>
+            </div>
+          </div>
+          ` : ""}
+        </div>
+      `).join("")}
+    </div>
+    ` : ""}
+    ${suggestions.usage_patterns && suggestions.usage_patterns.length > 0 ? `
+    <h2 id="section-patterns">New Ways to Use OpenCode</h2>
+    <p style="font-size: 13px; color: var(--text-muted); margin-bottom: 12px;">Just copy this into OpenCode and it'll walk you through it.</p>
+    <div class="patterns-section">
+      ${suggestions.usage_patterns.map((pat) => `
+        <div class="pattern-card">
+          <div class="pattern-title">${escapeHtml(pat.title || "")}</div>
+          <div class="pattern-summary">${escapeHtml(pat.suggestion || "")}</div>
+          ${pat.detail ? `<div class="pattern-detail">${escapeHtml(pat.detail)}</div>` : ""}
+          ${pat.copyable_prompt ? `
+          <div class="copyable-prompt-section">
+            <div class="prompt-label">Paste into OpenCode:</div>
+            <div class="copyable-prompt-row">
+              <code class="copyable-prompt">${escapeHtml(pat.copyable_prompt)}</code>
+              <button class="copy-btn" onclick="copyText(this)">Copy</button>
+            </div>
+          </div>
+          ` : ""}
+        </div>
+      `).join("")}
+    </div>
+    ` : `<h2 id="section-patterns" style="display:none;">New Ways to Use OpenCode</h2>`}
+    ` : `
+      <h2 id="section-features" style="display:none;">Features to Try</h2>
+      <h2 id="section-patterns" style="display:none;">New Ways to Use OpenCode</h2>
+    `;
+  const horizonData = insights.on_the_horizon;
+  const horizonHtml = horizonData?.opportunities && horizonData.opportunities.length > 0 ? `
+    <h2 id="section-horizon">On the Horizon</h2>
+    ${horizonData.intro ? `<p class="section-intro">${escapeHtml(horizonData.intro)}</p>` : ""}
+    <div class="horizon-section">
+      ${horizonData.opportunities.map((opp) => `
+        <div class="horizon-card">
+          <div class="horizon-title">${escapeHtml(opp.title || "")}</div>
+          <div class="horizon-possible">${escapeHtml(opp.whats_possible || "")}</div>
+          ${opp.how_to_try ? `<div class="horizon-tip"><strong>Getting started:</strong> ${escapeHtml(opp.how_to_try)}</div>` : ""}
+          ${opp.copyable_prompt ? `<div class="pattern-prompt"><div class="prompt-label">Paste into OpenCode:</div><code>${escapeHtml(opp.copyable_prompt)}</code><button class="copy-btn" onclick="copyText(this)">Copy</button></div>` : ""}
+        </div>
+      `).join("")}
+    </div>
+    ` : `<h2 id="section-horizon" style="display:none;">On the Horizon</h2>`;
+  const funEnding = insights.fun_ending;
+  const funEndingHtml = funEnding?.headline ? `
+    <h2 id="section-fun" style="display:none;">Fun Ending</h2>
+    <div class="fun-ending">
+      <div class="fun-headline">"${escapeHtml(funEnding.headline)}"</div>
+      ${funEnding.detail ? `<div class="fun-detail">${escapeHtml(funEnding.detail)}</div>` : ""}
+    </div>
+    ` : `<div id="section-fun" style="display:none;"></div>`;
+  const css = `
+    :root {
+      --bg-color: #f8fafc;
+      --text-main: #334155;
+      --text-heading: #0f172a;
+      --text-muted: #64748b;
+      --card-bg: #ffffff;
+      --border-color: #e2e8f0;
+      
+      --nav-bg: #f1f5f9;
+      --nav-hover: #e2e8f0;
+      
+      --glance-bg: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
+      --glance-border: #f59e0b;
+      --glance-title: #92400e;
+      --glance-text: #78350f;
+      --glance-link: #b45309;
+      
+      --win-bg: #f0fdf4;
+      --win-border: #bbf7d0;
+      --win-title: #166534;
+      --win-text: #15803d;
+      
+      --frict-bg: #fef2f2;
+      --frict-border: #fca5a5;
+      --frict-title: #991b1b;
+      --frict-text: #7f1d1d;
+      
+      --cmd-bg: #eff6ff;
+      --cmd-border: #bfdbfe;
+      --cmd-title: #1e40af;
+      
+      --code-bg: #f1f5f9;
+      
+      --feat-bg: #f0fdf4;
+      --feat-border: #86efac;
+      
+      --pat-bg: #f0f9ff;
+      --pat-border: #7dd3fc;
+      
+      --horiz-bg: linear-gradient(135deg, #faf5ff 0%, #f5f3ff 100%);
+      --horiz-border: #c4b5fd;
+      --horiz-title: #5b21b6;
+      --horiz-tip-bg: rgba(255,255,255,0.6);
+      
+      --fun-bg: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
+      --fun-border: #fbbf24;
+      --fun-title: #78350f;
+      --fun-text: #92400e;
+    }
+    body.dark {
+      --bg-color: #0f172a;
+      --text-main: #cbd5e1;
+      --text-heading: #f8fafc;
+      --text-muted: #94a3b8;
+      --card-bg: #1e293b;
+      --border-color: #334155;
+      
+      --nav-bg: #334155;
+      --nav-hover: #475569;
+      
+      --glance-bg: linear-gradient(135deg, #78350f 0%, #92400e 100%);
+      --glance-border: #b45309;
+      --glance-title: #fde68a;
+      --glance-text: #fef3c7;
+      --glance-link: #fcd34d;
+      
+      --win-bg: #14532d;
+      --win-border: #166534;
+      --win-title: #bbf7d0;
+      --win-text: #dcfce7;
+      
+      --frict-bg: #7f1d1d;
+      --frict-border: #991b1b;
+      --frict-title: #fca5a5;
+      --frict-text: #fecaca;
+      
+      --cmd-bg: #1e3a8a;
+      --cmd-border: #1e40af;
+      --cmd-title: #bfdbfe;
+      
+      --code-bg: #0f172a;
+      
+      --feat-bg: #064e3b;
+      --feat-border: #065f46;
+      
+      --pat-bg: #0c4a6e;
+      --pat-border: #075985;
+      
+      --horiz-bg: linear-gradient(135deg, #4c1d95 0%, #5b21b6 100%);
+      --horiz-border: #7c3aed;
+      --horiz-title: #ddd6fe;
+      --horiz-tip-bg: rgba(15,23,42,0.6);
+      
+      --fun-bg: linear-gradient(135deg, #78350f 0%, #92400e 100%);
+      --fun-border: #b45309;
+      --fun-title: #fef3c7;
+      --fun-text: #fde68a;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif; background: var(--bg-color); color: var(--text-main); line-height: 1.65; padding: 48px 24px; transition: background 0.2s, color 0.2s; }
+    .container { max-width: 800px; margin: 0 auto; position: relative; }
+    .theme-toggle { position: absolute; top: 0; right: 0; background: var(--card-bg); border: 1px solid var(--border-color); color: var(--text-main); padding: 6px 12px; border-radius: 6px; cursor: pointer; font-size: 14px; }
+    h1 { font-size: 32px; font-weight: 700; color: var(--text-heading); margin-bottom: 8px; }
+    h2 { font-size: 20px; font-weight: 600; color: var(--text-heading); margin-top: 48px; margin-bottom: 16px; }
+    .subtitle { color: var(--text-muted); font-size: 15px; margin-bottom: 32px; }
+    .nav-toc { display: flex; flex-wrap: wrap; gap: 8px; margin: 24px 0 32px 0; padding: 16px; background: var(--card-bg); border-radius: 8px; border: 1px solid var(--border-color); }
+    .nav-toc a { font-size: 12px; color: var(--text-muted); text-decoration: none; padding: 6px 12px; border-radius: 6px; background: var(--nav-bg); transition: all 0.15s; }
+    .nav-toc a:hover { background: var(--nav-hover); color: var(--text-main); }
+    .stats-row { display: flex; gap: 24px; margin-bottom: 40px; padding: 20px 0; border-top: 1px solid var(--border-color); border-bottom: 1px solid var(--border-color); flex-wrap: wrap; }
+    .stat { text-align: center; }
+    .stat-value { font-size: 24px; font-weight: 700; color: var(--text-heading); }
+    .stat-label { font-size: 11px; color: var(--text-muted); text-transform: uppercase; }
+    .at-a-glance { background: var(--glance-bg); border: 1px solid var(--glance-border); border-radius: 12px; padding: 20px 24px; margin-bottom: 32px; }
+    .glance-title { font-size: 16px; font-weight: 700; color: var(--glance-title); margin-bottom: 16px; }
+    .glance-sections { display: flex; flex-direction: column; gap: 12px; }
+    .glance-section { font-size: 14px; color: var(--glance-text); line-height: 1.6; }
+    .glance-section strong { color: var(--glance-title); }
+    .see-more { color: var(--glance-link); text-decoration: none; font-size: 13px; white-space: nowrap; }
+    .see-more:hover { text-decoration: underline; }
+    .project-areas { display: flex; flex-direction: column; gap: 12px; margin-bottom: 32px; }
+    .project-area { background: var(--card-bg); border: 1px solid var(--border-color); border-radius: 8px; padding: 16px; }
+    .area-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px; }
+    .area-name { font-weight: 600; font-size: 15px; color: var(--text-heading); }
+    .area-count { font-size: 12px; color: var(--text-muted); background: var(--nav-bg); padding: 2px 8px; border-radius: 4px; }
+    .area-desc { font-size: 14px; color: var(--text-main); line-height: 1.5; }
+    .narrative { background: var(--card-bg); border: 1px solid var(--border-color); border-radius: 8px; padding: 20px; margin-bottom: 24px; }
+    .narrative p { margin-bottom: 12px; font-size: 14px; color: var(--text-main); line-height: 1.7; }
+    .key-insight { background: var(--win-bg); border: 1px solid var(--win-border); border-radius: 8px; padding: 12px 16px; margin-top: 12px; font-size: 14px; color: var(--win-title); }
+    .section-intro { font-size: 14px; color: var(--text-muted); margin-bottom: 16px; }
+    .big-wins { display: flex; flex-direction: column; gap: 12px; margin-bottom: 24px; }
+    .big-win { background: var(--win-bg); border: 1px solid var(--win-border); border-radius: 8px; padding: 16px; }
+    .big-win-title { font-weight: 600; font-size: 15px; color: var(--win-title); margin-bottom: 8px; }
+    .big-win-desc { font-size: 14px; color: var(--win-text); line-height: 1.5; }
+    .friction-categories { display: flex; flex-direction: column; gap: 16px; margin-bottom: 24px; }
+    .friction-category { background: var(--frict-bg); border: 1px solid var(--frict-border); border-radius: 8px; padding: 16px; }
+    .friction-title { font-weight: 600; font-size: 15px; color: var(--frict-title); margin-bottom: 6px; }
+    .friction-desc { font-size: 13px; color: var(--frict-text); margin-bottom: 10px; }
+    .friction-examples { margin: 0 0 0 20px; font-size: 13px; color: var(--text-main); }
+    .friction-examples li { margin-bottom: 4px; }
+    .claude-md-section { background: var(--cmd-bg); border: 1px solid var(--cmd-border); border-radius: 8px; padding: 16px; margin-bottom: 20px; }
+    .claude-md-section h3 { font-size: 14px; font-weight: 600; color: var(--cmd-title); margin: 0 0 12px 0; }
+    .claude-md-actions { margin-bottom: 12px; padding-bottom: 12px; border-bottom: 1px solid var(--cmd-border); }
+    .copy-all-btn { background: #2563eb; color: white; border: none; border-radius: 4px; padding: 6px 12px; font-size: 12px; cursor: pointer; font-weight: 500; transition: all 0.2s; }
+    .copy-all-btn:hover { background: #1d4ed8; }
+    .copy-all-btn.copied { background: #16a34a; }
+    .claude-md-item { display: flex; flex-wrap: wrap; align-items: flex-start; gap: 8px; padding: 10px 0; border-bottom: 1px solid var(--cmd-border); }
+    .claude-md-item:last-child { border-bottom: none; }
+    .cmd-checkbox { margin-top: 2px; }
+    .cmd-code { background: var(--card-bg); padding: 8px 12px; border-radius: 4px; font-size: 12px; color: var(--cmd-title); border: 1px solid var(--cmd-border); font-family: monospace; display: block; white-space: pre-wrap; word-break: break-word; flex: 1; }
+    .cmd-why { font-size: 12px; color: var(--text-muted); width: 100%; padding-left: 24px; margin-top: 4px; }
+    .features-section, .patterns-section { display: flex; flex-direction: column; gap: 12px; margin: 16px 0; }
+    .feature-card { background: var(--feat-bg); border: 1px solid var(--feat-border); border-radius: 8px; padding: 16px; }
+    .pattern-card { background: var(--pat-bg); border: 1px solid var(--pat-border); border-radius: 8px; padding: 16px; }
+    .feature-title, .pattern-title { font-weight: 600; font-size: 15px; color: var(--text-heading); margin-bottom: 6px; }
+    .feature-oneliner, .pattern-summary { font-size: 14px; color: var(--text-main); margin-bottom: 8px; }
+    .feature-why, .pattern-detail { font-size: 13px; color: var(--text-main); line-height: 1.5; }
+    .feature-examples { margin-top: 12px; }
+    .feature-example { padding: 8px 0; border-top: 1px solid var(--feat-border); }
+    .feature-example:first-child { border-top: none; }
+    .example-code-row, .copyable-prompt-row { display: flex; align-items: flex-start; gap: 8px; }
+    .example-code { flex: 1; background: var(--code-bg); padding: 8px 12px; border-radius: 4px; font-family: monospace; font-size: 12px; color: var(--text-main); overflow-x: auto; white-space: pre-wrap; }
+    .copyable-prompt-section { margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border-color); }
+    .copyable-prompt { flex: 1; background: var(--card-bg); padding: 10px 12px; border-radius: 4px; font-family: monospace; font-size: 12px; color: var(--text-main); border: 1px solid var(--border-color); white-space: pre-wrap; line-height: 1.5; }
+    .pattern-prompt { background: var(--card-bg); padding: 12px; border-radius: 6px; margin-top: 12px; border: 1px solid var(--border-color); }
+    .pattern-prompt code { font-family: monospace; font-size: 12px; color: var(--text-main); display: block; white-space: pre-wrap; margin-bottom: 8px; }
+    .prompt-label { font-size: 11px; font-weight: 600; text-transform: uppercase; color: var(--text-muted); margin-bottom: 6px; }
+    .copy-btn { background: var(--nav-bg); border: none; border-radius: 4px; padding: 4px 8px; font-size: 11px; cursor: pointer; color: var(--text-muted); flex-shrink: 0; }
+    .copy-btn:hover { background: var(--nav-hover); color: var(--text-main); }
+    .charts-row { display: grid; grid-template-columns: 1fr 1fr; gap: 24px; margin: 24px 0; }
+    .chart-card { background: var(--card-bg); border: 1px solid var(--border-color); border-radius: 8px; padding: 16px; }
+    .chart-title { font-size: 12px; font-weight: 600; color: var(--text-muted); text-transform: uppercase; margin-bottom: 12px; }
+    .bar-row { display: flex; align-items: center; margin-bottom: 6px; }
+    .bar-label { width: 100px; font-size: 11px; color: var(--text-main); flex-shrink: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+    .bar-track { flex: 1; height: 6px; background: var(--nav-bg); border-radius: 3px; margin: 0 8px; }
+    .bar-fill { height: 100%; border-radius: 3px; }
+    .bar-value { width: 28px; font-size: 11px; font-weight: 500; color: var(--text-muted); text-align: right; }
+    .empty { color: var(--text-muted); font-size: 13px; }
+    .horizon-section { display: flex; flex-direction: column; gap: 16px; }
+    .horizon-card { background: var(--horiz-bg); border: 1px solid var(--horiz-border); border-radius: 8px; padding: 16px; }
+    .horizon-title { font-weight: 600; font-size: 15px; color: var(--horiz-title); margin-bottom: 8px; }
+    .horizon-possible { font-size: 14px; color: var(--text-main); margin-bottom: 10px; line-height: 1.5; }
+    .horizon-tip { font-size: 13px; color: var(--horiz-title); background: var(--horiz-tip-bg); padding: 8px 12px; border-radius: 4px; }
+    .fun-ending { background: var(--fun-bg); border: 1px solid var(--fun-border); border-radius: 12px; padding: 24px; margin-top: 40px; text-align: center; }
+    .fun-headline { font-size: 18px; font-weight: 600; color: var(--fun-title); margin-bottom: 8px; }
+    .fun-detail { font-size: 14px; color: var(--fun-text); }
+    @media (max-width: 640px) { .charts-row { grid-template-columns: 1fr; } .stats-row { justify-content: center; } }
+  `;
+  const hourCountsJson = getHourCountsJson(data.message_hours);
+  const js = `
+    function toggleTheme() {
+      document.body.classList.toggle('dark');
+      const isDark = document.body.classList.contains('dark');
+      localStorage.setItem('opencode-insights-theme', isDark ? 'dark' : 'light');
+    }
+    
+    // Check saved theme
+    if (localStorage.getItem('opencode-insights-theme') === 'dark') {
+      document.body.classList.add('dark');
+    } else if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches && !localStorage.getItem('opencode-insights-theme')) {
+      document.body.classList.add('dark');
+    }
+
+    function copyText(btn) {
+      const code = btn.previousElementSibling;
+      navigator.clipboard.writeText(code.textContent).then(() => {
+        btn.textContent = 'Copied!';
+        setTimeout(() => { btn.textContent = 'Copy'; }, 2000);
+      });
+    }
+    function copyCmdItem(idx) {
+      const checkbox = document.getElementById('cmd-' + idx);
+      if (checkbox) {
+        const text = checkbox.dataset.text;
+        navigator.clipboard.writeText(text).then(() => {
+          const btn = checkbox.nextElementSibling.querySelector('.copy-btn');
+          if (btn) { btn.textContent = 'Copied!'; setTimeout(() => { btn.textContent = 'Copy'; }, 2000); }
+        });
+      }
+    }
+    function copyAllCheckedAgentsMd() {
+      const checkboxes = document.querySelectorAll('.cmd-checkbox:checked');
+      const texts = [];
+      checkboxes.forEach(cb => {
+        if (cb.dataset.text) { texts.push(cb.dataset.text); }
+      });
+      const combined = texts.join('\\n');
+      const btn = document.querySelector('.copy-all-btn');
+      if (btn) {
+        navigator.clipboard.writeText(combined).then(() => {
+          btn.textContent = 'Copied ' + texts.length + ' items!';
+          btn.classList.add('copied');
+          setTimeout(() => { btn.textContent = 'Copy All Checked'; btn.classList.remove('copied'); }, 2000);
+        });
+      }
+    }
+    // Timezone selector for time of day chart
+    const rawHourCounts = ${hourCountsJson};
+    function updateHourHistogram(offsetFromPT) {
+      const periods = [
+        { label: "Morning (6-12)", range: [6,7,8,9,10,11] },
+        { label: "Afternoon (12-18)", range: [12,13,14,15,16,17] },
+        { label: "Evening (18-24)", range: [18,19,20,21,22,23] },
+        { label: "Night (0-6)", range: [0,1,2,3,4,5] }
+      ];
+      const adjustedCounts = {};
+      for (const [hour, count] of Object.entries(rawHourCounts)) {
+        const newHour = (parseInt(hour) + offsetFromPT + 24) % 24;
+        adjustedCounts[newHour] = (adjustedCounts[newHour] || 0) + count;
+      }
+      const periodCounts = periods.map(p => ({
+        label: p.label,
+        count: p.range.reduce((sum, h) => sum + (adjustedCounts[h] || 0), 0)
+      }));
+      const maxCount = Math.max(...periodCounts.map(p => p.count)) || 1;
+      const container = document.getElementById('hour-histogram');
+      container.textContent = '';
+      periodCounts.forEach(p => {
+        const row = document.createElement('div');
+        row.className = 'bar-row';
+        const label = document.createElement('div');
+        label.className = 'bar-label';
+        label.textContent = p.label;
+        const track = document.createElement('div');
+        track.className = 'bar-track';
+        const fill = document.createElement('div');
+        fill.className = 'bar-fill';
+        fill.style.width = (p.count / maxCount) * 100 + '%';
+        fill.style.background = '#8b5cf6';
+        track.appendChild(fill);
+        const value = document.createElement('div');
+        value.className = 'bar-value';
+        value.textContent = p.count;
+        row.appendChild(label);
+        row.appendChild(track);
+        row.appendChild(value);
+        container.appendChild(row);
+      });
+    }
+    document.getElementById('timezone-select').addEventListener('change', function() {
+      const customInput = document.getElementById('custom-offset');
+      if (this.value === 'custom') {
+        customInput.style.display = 'inline-block';
+        customInput.focus();
+      } else {
+        customInput.style.display = 'none';
+        updateHourHistogram(parseInt(this.value));
+      }
+    });
+    document.getElementById('custom-offset').addEventListener('change', function() {
+      const offset = parseInt(this.value) + 8;
+      updateHourHistogram(offset);
+    });
+  `;
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>OpenCode Insights</title>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+  <style>${css}</style>
+</head>
+<body>
+  <div class="container">
+    <button class="theme-toggle" onclick="toggleTheme()" title="Toggle Dark Mode">\uD83C\uDF13 Theme</button>
+    <h1>OpenCode Insights</h1>
+    <p class="subtitle">${data.total_messages?.toLocaleString() || 0} messages across ${data.total_sessions || 0} sessions${data.total_sessions_scanned && data.total_sessions_scanned > data.total_sessions ? ` (${data.total_sessions_scanned.toLocaleString()} total)` : ""} | ${data.date_range?.start || ""} to ${data.date_range?.end || ""}</p>
+
+    ${atAGlanceHtml}
+
+    <nav class="nav-toc">
+      <a href="#section-glance">At a Glance</a>
+      <a href="#section-projects">What You Work On</a>
+      <a href="#section-style">How You Use OpenCode</a>
+      <a href="#section-wins">Impressive Things</a>
+      <a href="#section-friction">Where Things Go Wrong</a>
+      <a href="#section-features">Features to Try</a>
+      <a href="#section-patterns">New Usage Patterns</a>
+      <a href="#section-horizon">On the Horizon</a>
+      <a href="#section-fun">Fun Ending</a>
+    </nav>
+
+    <div class="stats-row" id="section-stats">
+      <div class="stat"><div class="stat-value">${data.total_messages?.toLocaleString() || 0}</div><div class="stat-label">Messages</div></div>
+      <div class="stat"><div class="stat-value">+${data.total_lines_added?.toLocaleString() || 0}/-${data.total_lines_removed?.toLocaleString() || 0}</div><div class="stat-label">Lines</div></div>
+      <div class="stat"><div class="stat-value">${data.total_files_modified || 0}</div><div class="stat-label">Files</div></div>
+      <div class="stat"><div class="stat-value">${data.days_active || 0}</div><div class="stat-label">Days</div></div>
+      <div class="stat"><div class="stat-value">${data.messages_per_day || 0}</div><div class="stat-label">Msgs/Day</div></div>
+    </div>
+
+    ${projectAreasHtml}
+
+    <div class="charts-row">
+      <div class="chart-card">
+        <div class="chart-title">What You Wanted</div>
+        ${generateBarChart(data.goal_categories, "#2563eb")}
+      </div>
+      <div class="chart-card">
+        <div class="chart-title">Top Tools Used</div>
+        ${generateBarChart(data.tool_counts, "#0891b2")}
+      </div>
+    </div>
+
+    <div class="charts-row">
+      <div class="chart-card">
+        <div class="chart-title">Languages</div>
+        ${generateBarChart(data.languages, "#10b981")}
+      </div>
+      <div class="chart-card">
+        <div class="chart-title">Session Types</div>
+        ${generateBarChart(data.session_types || {}, "#8b5cf6")}
+      </div>
+    </div>
+
+    ${interactionHtml}
+
+    <!-- Response Time Distribution -->
+    <div class="chart-card" style="margin: 24px 0;">
+      <div class="chart-title">User Response Time Distribution</div>
+      ${generateResponseTimeHistogram(data.user_response_times)}
+      <div style="font-size: 12px; color: var(--text-muted); margin-top: 8px;">
+        Median: ${data.median_response_time?.toFixed(1) || 0}s &bull; Average: ${data.avg_response_time?.toFixed(1) || 0}s
+      </div>
+    </div>
+
+    <!-- Multi-clauding Section -->
+    <div class="chart-card" style="margin: 24px 0;">
+      <div class="chart-title">Multi-Clauding (Parallel Sessions)</div>
+      ${data.multi_clauding?.overlap_events === 0 || !data.multi_clauding ? `
+        <p style="font-size: 14px; color: var(--text-muted); padding: 8px 0;">
+          No parallel session usage detected. You typically work with one OpenCode session at a time.
+        </p>
+      ` : `
+        <div style="display: flex; gap: 24px; margin: 12px 0;">
+          <div style="text-align: center;">
+            <div style="font-size: 24px; font-weight: 700; color: #7c3aed;">${data.multi_clauding.overlap_events}</div>
+            <div style="font-size: 11px; color: var(--text-muted); text-transform: uppercase;">Overlap Events</div>
+          </div>
+          <div style="text-align: center;">
+            <div style="font-size: 24px; font-weight: 700; color: #7c3aed;">${data.multi_clauding.sessions_involved}</div>
+            <div style="font-size: 11px; color: var(--text-muted); text-transform: uppercase;">Sessions Involved</div>
+          </div>
+          <div style="text-align: center;">
+            <div style="font-size: 24px; font-weight: 700; color: #7c3aed;">${data.total_messages > 0 ? Math.round(100 * data.multi_clauding.user_messages_during / data.total_messages) : 0}%</div>
+            <div style="font-size: 11px; color: var(--text-muted); text-transform: uppercase;">Of Messages</div>
+          </div>
+        </div>
+        <p style="font-size: 13px; color: var(--text-main); margin-top: 12px;">
+          You run multiple OpenCode sessions simultaneously. Multi-clauding is detected when sessions
+          overlap in time, suggesting parallel workflows.
+        </p>
+      `}
+    </div>
+
+    <!-- Time of Day & Tool Errors -->
+    <div class="charts-row">
+      <div class="chart-card">
+        <div class="chart-title" style="display: flex; align-items: center; gap: 12px;">
+          User Messages by Time of Day
+          <select id="timezone-select" style="background: var(--card-bg); color: var(--text-main); font-size: 12px; padding: 4px 8px; border-radius: 4px; border: 1px solid var(--border-color);">
+            <option value="0">PT (UTC-8)</option>
+            <option value="3">ET (UTC-5)</option>
+            <option value="8">London (UTC)</option>
+            <option value="9">CET (UTC+1)</option>
+            <option value="17">Tokyo (UTC+9)</option>
+            <option value="custom">Custom offset...</option>
+          </select>
+          <input type="number" id="custom-offset" placeholder="UTC offset" style="display: none; background: var(--card-bg); color: var(--text-main); width: 80px; font-size: 12px; padding: 4px; border-radius: 4px; border: 1px solid var(--border-color);">
+        </div>
+        ${generateTimeOfDayChart(data.message_hours)}
+      </div>
+      <div class="chart-card">
+        <div class="chart-title">Tool Errors Encountered</div>
+        ${data.tool_error_categories && Object.keys(data.tool_error_categories).length > 0 ? generateBarChart(data.tool_error_categories, "#dc2626") : '<p class="empty">No tool errors</p>'}
+      </div>
+    </div>
+
+    ${whatWorksHtml}
+
+    <div class="charts-row">
+      <div class="chart-card">
+        <div class="chart-title">What Helped Most</div>
+        ${generateBarChart(data.success, "#16a34a")}
+      </div>
+      <div class="chart-card">
+        <div class="chart-title">Outcomes</div>
+        ${generateBarChart(data.outcomes, "#8b5cf6", 6, OUTCOME_ORDER)}
+      </div>
+    </div>
+
+    ${frictionHtml}
+
+    <div class="charts-row">
+      <div class="chart-card">
+        <div class="chart-title">Primary Friction Types</div>
+        ${generateBarChart(data.friction, "#dc2626")}
+      </div>
+      <div class="chart-card">
+        <div class="chart-title">Inferred Satisfaction (model-estimated)</div>
+        ${generateBarChart(data.satisfaction, "#eab308", 6, SATISFACTION_ORDER)}
+      </div>
+    </div>
+
+    ${suggestionsHtml}
+
+    ${horizonHtml}
+
+    ${funEndingHtml}
+
+  </div>
+  <script>${js}</script>
+</body>
+</html>`;
+}
+
+// src/insights/handler.ts
+var MAX_SESSION_SUMMARIES2 = 50;
+function getDefaultDbPath3() {
+  return `${Bun.env?.HOME ?? ""}/.local/share/opencode/opencode.db`;
+}
+function dedupSessionsById(sessions) {
+  const bestById = new Map;
+  for (const session of sessions) {
+    const existing = bestById.get(session.id);
+    if (!existing || session.user_message_count > existing.user_message_count) {
+      bestById.set(session.id, session);
+    }
+  }
+  return Array.from(bestById.values()).sort((a, b) => b.time_updated - a.time_updated);
+}
+function getReportSnapshotPath() {
+  return `${getReportDir()}/report-cache.json`;
+}
+function incrementCounter3(record, key, amount = 1) {
+  record[key] = (record[key] || 0) + amount;
+}
+function incrementEntries2(target, source) {
+  for (const [key, count] of Object.entries(source)) {
+    if (count > 0) {
+      incrementCounter3(target, key, count);
+    }
+  }
+}
+function parseNumber(text) {
+  if (!text)
+    return null;
+  const parsed = Number(text.replace(/,/g, ""));
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function stripHtml(value) {
+  return value.replace(/<br\s*\/?>/gi, `
+`).replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#039;/g, "'").trim();
+}
+function parseSummaryFromReportHtml(html) {
+  const match = html.match(/([\d,]+)\s+messages\s+across\s+([\d,]+)\s+sessions(?:\s+\(([\d,]+)\s+total\))?/i);
+  return {
+    totalMessages: parseNumber(match?.[1]),
+    totalSessions: parseNumber(match?.[2]),
+    totalSessionsScanned: parseNumber(match?.[3])
+  };
+}
+function parseDateRangeFromReportHtml(html) {
+  const match = html.match(/(\d{4}-\d{2}-\d{2})\s+to\s+(\d{4}-\d{2}-\d{2})/);
+  if (!match)
+    return null;
+  const start = match[1];
+  const end = match[2];
+  if (!start || !end)
+    return null;
+  return { start, end };
+}
+function recoverAtAGlanceFromReportHtml(html) {
+  const extractLine = (label, sectionId) => {
+    const pattern = new RegExp(`<strong>${label}:<\\/strong>\\s*([\\s\\S]*?)\\s*<a href="#${sectionId}"`, "i");
+    const match = html.match(pattern);
+    return stripHtml(match?.[1] ?? "");
+  };
+  const whatsWorking = extractLine("What's working", "section-wins");
+  const whatsHindering = extractLine("What's hindering you", "section-friction");
+  const quickWins = extractLine("Quick wins to try", "section-features");
+  const ambitiousWorkflows = extractLine("Ambitious workflows", "section-horizon");
+  if (!whatsWorking && !whatsHindering && !quickWins && !ambitiousWorkflows) {
+    return {};
+  }
+  return {
+    at_a_glance: {
+      ...whatsWorking ? { whats_working: whatsWorking } : {},
+      ...whatsHindering ? { whats_hindering: whatsHindering } : {},
+      ...quickWins ? { quick_wins: quickWins } : {},
+      ...ambitiousWorkflows ? { ambitious_workflows: ambitiousWorkflows } : {}
+    }
+  };
+}
+function rebuildAggregatedDataFromCachedArtifacts(facets, reportHtml) {
+  const data = aggregateData([], new Map);
+  data.total_sessions = facets.size;
+  data.sessions_with_facets = facets.size;
+  data.total_sessions_scanned = facets.size;
+  for (const facet of facets.values()) {
+    incrementEntries2(data.goal_categories, facet.goal_categories);
+    incrementCounter3(data.outcomes, facet.outcome);
+    incrementEntries2(data.satisfaction, facet.user_satisfaction_counts);
+    incrementCounter3(data.helpfulness, facet.claude_helpfulness);
+    incrementCounter3(data.session_types, facet.session_type);
+    incrementEntries2(data.friction, facet.friction_counts);
+    if (facet.primary_success !== "none") {
+      incrementCounter3(data.success, facet.primary_success);
+    }
+    if (data.session_summaries.length < MAX_SESSION_SUMMARIES2) {
+      data.session_summaries.push({
+        id: facet.session_id,
+        date: "",
+        summary: facet.brief_summary,
+        goal: facet.underlying_goal
+      });
+    }
+  }
+  const parsedSummary = parseSummaryFromReportHtml(reportHtml);
+  if (parsedSummary.totalMessages !== null) {
+    data.total_messages = parsedSummary.totalMessages;
+  }
+  if (parsedSummary.totalSessions !== null) {
+    data.total_sessions = parsedSummary.totalSessions;
+  }
+  if (parsedSummary.totalSessionsScanned !== null) {
+    data.total_sessions_scanned = parsedSummary.totalSessionsScanned;
+  }
+  const parsedRange = parseDateRangeFromReportHtml(reportHtml);
+  if (parsedRange) {
+    data.date_range = parsedRange;
+  }
+  return data;
+}
+async function loadFacetsFromDisk() {
+  const facets = new Map;
+  const facetsDir = getFacetsDir();
+  try {
+    const entries = await readdir2(facetsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".json"))
+        continue;
+      const facetPath = `${facetsDir}/${entry.name}`;
+      try {
+        const parsed = await Bun.file(facetPath).json();
+        if (isValidSessionFacets(parsed)) {
+          facets.set(parsed.session_id, parsed);
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return facets;
+  }
+  return facets;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCachedReportPayload(value) {
+  if (!isRecord(value))
+    return false;
+  if (!Array.isArray(value.facets))
+    return false;
+  if (!value.facets.every((facet) => isValidSessionFacets(facet)))
+    return false;
+  if (!isRecord(value.insights))
+    return false;
+  if (!isRecord(value.data))
+    return false;
+  return true;
+}
+async function loadCachedReportPayload() {
+  const snapshotPath = getReportSnapshotPath();
+  try {
+    const file = Bun.file(snapshotPath);
+    if (!await file.exists())
+      return null;
+    const parsed = await file.json();
+    if (!isCachedReportPayload(parsed))
+      return null;
+    const facets = new Map;
+    for (const facet of parsed.facets) {
+      facets.set(facet.session_id, facet);
+    }
+    return {
+      insights: parsed.insights,
+      data: parsed.data,
+      facets
+    };
+  } catch {
+    return null;
+  }
+}
+async function saveCachedReportPayload(insights, data, facets) {
+  const snapshotPath = getReportSnapshotPath();
+  try {
+    await mkdir3(dirname2(snapshotPath), { recursive: true });
+    const payload = {
+      insights,
+      data,
+      facets: Array.from(facets.values())
+    };
+    await Bun.write(snapshotPath, JSON.stringify(payload, null, 2));
+  } catch {
+    return;
+  }
+}
+async function restoreCachedResult(htmlPath) {
+  const snapshot = await loadCachedReportPayload();
+  if (snapshot) {
+    return snapshot;
+  }
+  let reportHtml = "";
+  try {
+    reportHtml = await Bun.file(htmlPath).text();
+  } catch {
+    reportHtml = "";
+  }
+  const facets = await loadFacetsFromDisk();
+  const insights = recoverAtAGlanceFromReportHtml(reportHtml);
+  const data = rebuildAggregatedDataFromCachedArtifacts(facets, reportHtml);
+  return { insights, data, facets };
+}
+function filterMinimalSessions(sessions, facets) {
+  const filteredFacets = new Map;
+  for (const [sessionId, facet] of facets.entries()) {
+    if (!isMinimalSession(facet)) {
+      filteredFacets.set(sessionId, facet);
+    }
+  }
+  const filteredSessions = sessions.filter((session) => {
+    const facet = facets.get(session.id);
+    if (!facet)
+      return true;
+    return !isMinimalSession(facet);
+  });
+  return { sessions: filteredSessions, facets: filteredFacets };
+}
+async function collectSessionArtifacts(sessions, dbPath) {
+  const messages = new Map;
+  const parts = new Map;
+  const path = dbPath ?? getDefaultDbPath3();
+  await Promise.all(sessions.map(async (session) => {
+    const [sessionMessages, sessionParts] = await Promise.all([
+      collectMessages(path, session.id).catch(() => []),
+      collectParts(path, session.id).catch(() => [])
+    ]);
+    messages.set(session.id, sessionMessages);
+    parts.set(session.id, sessionParts);
+  }));
+  return { messages, parts };
+}
+async function generateUsageReport(client, options = {}) {
+  const htmlPath = getReportPath();
+  if (await isReportFresh(options?.dbPath)) {
+    options.onProgress?.({ stage: "cache-hit" });
+    const cached = await restoreCachedResult(htmlPath);
+    buildExportData(cached.data, cached.insights, cached.facets);
+    buildPromptForCommand(cached.insights, htmlPath, cached.data, getFacetsDir());
+    return {
+      insights: cached.insights,
+      htmlPath,
+      data: cached.data,
+      facets: cached.facets
+    };
+  }
+  const sessions = await collectSessions({
+    dbPath: options?.dbPath,
+    days: options?.days,
+    project: options?.project
+  });
+  const dedupedSessions = dedupSessionsById(sessions);
+  const substantiveSessions = dedupedSessions.filter(isSubstantiveSession);
+  const analyzedSessions = substantiveSessions.slice(0, MAX_SESSIONS);
+  options.onProgress?.({
+    stage: "sessions-collected",
+    completed: analyzedSessions.length,
+    total: dedupedSessions.length
+  });
+  const { messages, parts } = await collectSessionArtifacts(analyzedSessions, options?.dbPath);
+  const extractedFacets = await extractAllFacets(client, analyzedSessions, messages, parts, new Map);
+  const filtered = filterMinimalSessions(analyzedSessions, extractedFacets);
+  const data = aggregateData(filtered.sessions, filtered.facets);
+  data.total_sessions_scanned = dedupedSessions.length;
+  const insights = await generateParallelInsights(client, data, filtered.facets, options.onProgress);
+  const html = generateHtmlReport(data, insights);
+  await mkdir3(dirname2(htmlPath), { recursive: true });
+  await Bun.write(htmlPath, html);
+  await saveCachedReportPayload(insights, data, filtered.facets);
+  buildExportData(data, insights, filtered.facets);
+  buildPromptForCommand(insights, htmlPath, data, getFacetsDir());
+  return {
+    insights,
+    htmlPath,
+    data,
+    facets: filtered.facets
+  };
+}
+
+// src/plugins/insights.ts
+var insightsPlugin = async ({ client }) => {
+  return {
+    tool: {
+      insights_generate: tool({
+        description: "Generate an LLM-driven usage insights report analyzing your OpenCode sessions",
+        args: {
+          days: tool.schema.number().optional(),
+          project: tool.schema.string().optional()
+        },
+        execute: async ({ days, project }, ctx) => {
+          ctx.metadata({
+            title: "Generating OpenCode insights",
+            metadata: { stage: "pipeline:start" }
+          });
+          const result = await generateUsageReport(client, {
+            days,
+            project,
+            onProgress: (metadata) => {
+              ctx.metadata({
+                title: "Generating OpenCode insights",
+                metadata
+              });
+            }
+          });
+          return buildPromptForCommand(result.insights, result.htmlPath ?? getReportPath(), result.data, getFacetsDir());
+        }
+      })
+    }
+  };
+};
 // src/plugins/leaderboard.ts
 function getHome3() {
   return Bun.env?.HOME ?? (globalThis?.process?.env?.HOME ?? "") ?? "";
@@ -1171,6 +3664,7 @@ export {
   toolCallNotifyPlugin,
   notifyPlugin,
   leaderboardPlugin,
+  insightsPlugin,
   compactionPlugin,
   backgroundSubagentPlugin,
   autoMemoryPlugin