getprismo 0.1.27 → 0.1.29

package/README.md

@@ -1,5 +1,9 @@
 # prismodev
 
+[![npm version](https://img.shields.io/npm/v/getprismo.svg)](https://www.npmjs.com/package/getprismo)
+[![npm downloads](https://img.shields.io/npm/dw/getprismo.svg)](https://www.npmjs.com/package/getprismo)
+[![license: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
 local ai coding cost control. one command to diagnose token waste, fix it, and prove the improvement.
 
 ```bash
@@ -545,9 +549,49 @@ it only creates new files and recommendations. you decide what to apply.
 
 ---
 
+## cursor session tracking
+
+prismodev now reads cursor's local sqlite databases directly. cursor stores data differently from claude code and codex, no jsonl session logs, but it has its own tracking databases with unique data.
+
+```bash
+npx getprismo cursor                     # summary of all cursor sessions
+npx getprismo cursor list                # list composer sessions with modes and models
+npx getprismo cursor authorship          # ai vs human code authorship from scored commits
+npx getprismo cursor timeline            # timeline of ai activity across commits and files
+npx getprismo cursor files               # ai-generated and ai-deleted file tracking
+npx getprismo cursor --json              # machine-readable output
+```
+
+cursor tracks something claude code and codex can't: per-commit ai authorship. every commit is scored with how many lines came from composer (agent), tab completions, and human typing. prismodev surfaces this as an authorship percentage.
+
+```
+AI Authorship (from Cursor scored commits)
+
+Commits analyzed: 47
+Total lines added: 3812
+
+  Composer (agent):  2104 lines
+  Tab completions:   891 lines
+  Human:             817 lines
+--------------------------------------------------
+  AI authorship:     78%
+```
+
+prismodev also tracks ai-generated files cursor is watching, files cursor deleted, conversation summaries, and model usage distribution across sessions.
+
+what cursor can't do vs claude code: cursor doesn't expose per-message token counts, exact api costs, or full conversation transcripts in its local data. that means live context pressure, loop detection, exact cost breakdowns, cache savings analysis, and shield don't apply the same way. this is a cursor limitation. prismodev gets about 60-65% feature parity with cursor compared to claude code/codex.
+
+what cursor gives you that the others don't: ai authorship percentages per commit, tab vs composer vs human line counts, conversation summaries with tldr, and ai-generated file tracking with churn detection.
+
+the `prismo_cursor_sessions` mcp tool exposes all of this to compatible agents.
+
+`scan` and `doctor` now detect cursor's tracking database automatically and flag ai-generated files still present in the repo.
+
+---
+
 ## how watch catches waste live
 
-watch reads local session logs from codex and claude code. it detects:
+watch reads local session logs from codex, claude code, and cursor. it detects:
 
 | signal | what it means |
 |--------|--------------|
@@ -623,6 +667,7 @@ no install needed. npx runs it directly.
 | `watch` | live session monitoring with warnings |
 | `cc` | claude code cost breakdown |
 | `cc timeline` | session reconstruction with events |
+| `cursor` | cursor session tracking and ai authorship |
 | `scan --usage` | full repo scan with local usage data |
 | `scan --optimizer-fit` | recommend which token-optimization path fits your repo/session |
 | `scan --report-card` | shortest decision-layer summary |
@@ -677,6 +722,7 @@ npx getprismo watch --rescue --json      # include rescuePrompt in JSON
 npx getprismo watch --once --redact-paths # hide local paths
 npx getprismo watch codex                # only codex sessions
 npx getprismo watch claude               # only claude code sessions
+npx getprismo watch cursor               # only cursor sessions
 ```
 
 ### shield mode
@@ -708,6 +754,7 @@ npx getprismo mcp /path/to/repo
 - `prismo_context_pack`
 - `prismo_firewall`
 - `prismo_cc_timeline`
+- `prismo_cursor_sessions`
 
 This lets an MCP-compatible agent search prior shielded test/build output, request scoped context packs, inspect token-waste signals, or coordinate multiple local agents without pasting giant logs into the conversation.
 
@@ -802,9 +849,10 @@ local logs        exact when codex/claude session logs expose token fields
 prismo proxy      exact usage/cost when traffic routes through prismo base url
 ```
 
-prismodev reads local session logs from:
+prismodev reads local session data from:
 - codex: `~/.codex/sessions/**/*.jsonl`
 - claude code: `~/.claude/projects/**/*.jsonl`
+- cursor: `~/.cursor/ai-tracking/ai-code-tracking.db` and `~/Library/Application Support/Cursor/User/globalStorage/state.vscdb`
 
 no api keys. no intercepted prompts. no data uploaded.
 
@@ -890,7 +938,8 @@ lib/prismo-dev/scan-path-utils.js scan ignore/path helper logic
 lib/prismo-dev/shield.js         local command shield and searchable output index
 lib/prismo-dev/usage-cost.js     Claude Code cost and timeline analysis
 lib/prismo-dev/usage-log-utils.js local session log parsing helpers
-lib/prismo-dev/usage-sessions.js local Codex/Claude session discovery
+lib/prismo-dev/cursor-sessions.js Cursor SQLite session and authorship tracking
+lib/prismo-dev/usage-sessions.js local Codex/Claude/Cursor session discovery
 lib/prismo-dev/usage-watch.js    watch orchestration, JSON payloads, live files
 lib/prismo-dev/utils.js          shared terminal/file/token helpers
 lib/prismo-dev/watch-live.js     live context-pressure decisions
@@ -910,6 +959,7 @@ npx getprismo shield --help
 npx getprismo mcp --help
 npx getprismo mcp doctor
 npx getprismo cc --help
+npx getprismo cursor --help
 npx getprismo scan --help
 ```
 

package/lib/prismo-dev/cursor-sessions.js

@@ -0,0 +1,641 @@
+module.exports = function createCursorSessions(deps) {
+  const { fs, os, path, estimateTokens } = deps;
+
+  function getCursorHome() {
+    return process.env.PRISMO_CURSOR_HOME || path.join(os.homedir(), ".cursor");
+  }
+  function getCursorAppSupport() {
+    return process.env.PRISMO_CURSOR_APP_SUPPORT || path.join(os.homedir(), "Library", "Application Support", "Cursor");
+  }
+  function getAiTrackingDbPath() {
+    return path.join(getCursorHome(), "ai-tracking", "ai-code-tracking.db");
+  }
+  function getGlobalStateDbPath() {
+    return path.join(getCursorAppSupport(), "User", "globalStorage", "state.vscdb");
+  }
+  function getIdeStatePath() {
+    return path.join(getCursorHome(), "ide_state.json");
+  }
+
+  let sqlite3Available = null;
+  let spawnSyncFn = null;
+
+  function getSpawnSync() {
+    if (!spawnSyncFn) {
+      spawnSyncFn = require("child_process").spawnSync;
+    }
+    return spawnSyncFn;
+  }
+
+  function isSqlite3Available() {
+    if (sqlite3Available !== null) return sqlite3Available;
+    try {
+      const result = getSpawnSync()("sqlite3", ["--version"], { timeout: 3000, stdio: "pipe" });
+      sqlite3Available = result.status === 0;
+    } catch {
+      sqlite3Available = false;
+    }
+    return sqlite3Available;
+  }
+
+  function querySqlite(dbPath, sql) {
+    if (!isSqlite3Available()) return [];
+    if (!fs.existsSync(dbPath)) return [];
+    try {
+      const result = getSpawnSync()("sqlite3", ["-json", dbPath, sql], {
+        timeout: 10000,
+        stdio: "pipe",
+        maxBuffer: 8 * 1024 * 1024,
+      });
+      if (result.status !== 0) return [];
+      const output = (result.stdout || "").toString().trim();
+      if (!output) return [];
+      return JSON.parse(output);
+    } catch {
+      return [];
+    }
+  }
+
+  function querySqliteCsv(dbPath, sql) {
+    if (!isSqlite3Available()) return [];
+    if (!fs.existsSync(dbPath)) return [];
+    try {
+      const result = getSpawnSync()("sqlite3", ["-header", "-csv", dbPath, sql], {
+        timeout: 10000,
+        stdio: "pipe",
+        maxBuffer: 8 * 1024 * 1024,
+      });
+      if (result.status !== 0) return [];
+      const output = (result.stdout || "").toString().trim();
+      if (!output) return [];
+      const lines = output.split(/\r?\n/);
+      if (lines.length < 2) return [];
+      const headers = parseCsvLine(lines[0]);
+      return lines.slice(1).map((line) => {
+        const values = parseCsvLine(line);
+        const row = {};
+        headers.forEach((header, i) => { row[header] = values[i] || ""; });
+        return row;
+      });
+    } catch {
+      return [];
+    }
+  }
+
+  function parseCsvLine(line) {
+    const values = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      if (inQuotes) {
+        if (ch === '"' && line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else if (ch === '"') {
+          inQuotes = false;
+        } else {
+          current += ch;
+        }
+      } else if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ",") {
+        values.push(current);
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+    values.push(current);
+    return values;
+  }
+
+  function queryDb(dbPath, sql) {
+    const rows = querySqlite(dbPath, sql);
+    if (rows.length) return rows;
+    return querySqliteCsv(dbPath, sql);
+  }
+
+  function getCursorScoredCommits(limit = 50) {
+    const sql = `SELECT branchName, commitHash, commitMessage, commitDate,
+      linesAdded, linesDeleted, tabLinesAdded, tabLinesDeleted,
+      composerLinesAdded, composerLinesDeleted,
+      humanLinesAdded, humanLinesDeleted,
+      blankLinesAdded, blankLinesDeleted,
+      v1AiPercentage, v2AiPercentage, scoredAt
+      FROM scored_commits ORDER BY scoredAt DESC LIMIT ${limit}`;
+    return queryDb(getAiTrackingDbPath(), sql).map((row) => ({
+      branchName: row.branchName || "",
+      commitHash: row.commitHash || "",
+      commitMessage: row.commitMessage || "",
+      commitDate: row.commitDate || "",
+      linesAdded: Number(row.linesAdded) || 0,
+      linesDeleted: Number(row.linesDeleted) || 0,
+      tabLinesAdded: Number(row.tabLinesAdded) || 0,
+      tabLinesDeleted: Number(row.tabLinesDeleted) || 0,
+      composerLinesAdded: Number(row.composerLinesAdded) || 0,
+      composerLinesDeleted: Number(row.composerLinesDeleted) || 0,
+      humanLinesAdded: Number(row.humanLinesAdded) || 0,
+      humanLinesDeleted: Number(row.humanLinesDeleted) || 0,
+      blankLinesAdded: Number(row.blankLinesAdded) || 0,
+      blankLinesDeleted: Number(row.blankLinesDeleted) || 0,
+      v1AiPercentage: row.v1AiPercentage || "",
+      v2AiPercentage: row.v2AiPercentage || "",
+      scoredAt: Number(row.scoredAt) || 0,
+    }));
+  }
+
+  function getCursorAiCodeHashes(limit = 100) {
+    const sql = `SELECT hash, source, fileExtension, fileName, requestId,
+      conversationId, timestamp, model, createdAt
+      FROM ai_code_hashes ORDER BY createdAt DESC LIMIT ${limit}`;
+    return queryDb(getAiTrackingDbPath(), sql).map((row) => ({
+      hash: row.hash || "",
+      source: row.source || "",
+      fileExtension: row.fileExtension || "",
+      fileName: row.fileName || "",
+      requestId: row.requestId || "",
+      conversationId: row.conversationId || "",
+      timestamp: Number(row.timestamp) || 0,
+      model: row.model || "",
+      createdAt: Number(row.createdAt) || 0,
+    }));
+  }
+
+  function getCursorConversationSummaries(limit = 50) {
+    const sql = `SELECT conversationId, title, tldr, overview, summaryBullets,
+      model, mode, updatedAt
+      FROM conversation_summaries ORDER BY updatedAt DESC LIMIT ${limit}`;
+    return queryDb(getAiTrackingDbPath(), sql).map((row) => ({
+      conversationId: row.conversationId || "",
+      title: row.title || "",
+      tldr: row.tldr || "",
+      overview: row.overview || "",
+      summaryBullets: row.summaryBullets || "",
+      model: row.model || "",
+      mode: row.mode || "",
+      updatedAt: Number(row.updatedAt) || 0,
+    }));
+  }
+
+  function getCursorTrackedFileContent(limit = 50) {
+    const sql = `SELECT gitPath, conversationId, model, fileExtension, createdAt,
+      length(content) as contentLength
+      FROM tracked_file_content ORDER BY createdAt DESC LIMIT ${limit}`;
+    return queryDb(getAiTrackingDbPath(), sql).map((row) => ({
+      gitPath: row.gitPath || "",
+      conversationId: row.conversationId || "",
+      model: row.model || "",
+      fileExtension: row.fileExtension || "",
+      createdAt: Number(row.createdAt) || 0,
+      contentLength: Number(row.contentLength) || 0,
+    }));
+  }
+
+  function getCursorDeletedFiles(limit = 50) {
+    const sql = `SELECT gitPath, composerId, conversationId, model, deletedAt
+      FROM ai_deleted_files ORDER BY deletedAt DESC LIMIT ${limit}`;
+    return queryDb(getAiTrackingDbPath(), sql).map((row) => ({
+      gitPath: row.gitPath || "",
+      composerId: row.composerId || "",
+      conversationId: row.conversationId || "",
+      model: row.model || "",
+      deletedAt: Number(row.deletedAt) || 0,
+    }));
+  }
+
+  function getCursorComposerHeaders() {
+    const rows = queryDb(getGlobalStateDbPath(),
+      "SELECT value FROM ItemTable WHERE key = 'composer.composerHeaders'");
+    if (!rows.length) return [];
+    try {
+      const raw = rows[0].value || rows[0];
+      const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+      return (data.allComposers || []).map((c) => ({
+        composerId: c.composerId || "",
+        createdAt: Number(c.createdAt) || 0,
+        mode: c.unifiedMode || c.forceMode || "",
+        linesAdded: Number(c.totalLinesAdded) || 0,
+        linesRemoved: Number(c.totalLinesRemoved) || 0,
+        isArchived: Boolean(c.isArchived),
+        isDraft: Boolean(c.isDraft),
+        isWorktree: Boolean(c.isWorktree),
+        isSpec: Boolean(c.isSpec),
+        numSubComposers: Number(c.numSubComposers) || 0,
+        workspaceId: c.workspaceIdentifier?.id || "",
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  function getCursorWorkspaceForProject(projectPath) {
+    const wsDir = path.join(getCursorAppSupport(), "User", "workspaceStorage");
+    if (!fs.existsSync(wsDir)) return null;
+    try {
+      const entries = fs.readdirSync(wsDir);
+      for (const entry of entries) {
+        const wsJson = path.join(wsDir, entry, "workspace.json");
+        if (!fs.existsSync(wsJson)) continue;
+        try {
+          const data = JSON.parse(fs.readFileSync(wsJson, "utf8"));
+          const folder = decodeURIComponent((data.folder || "").replace("file://", ""));
+          if (folder && path.resolve(folder) === path.resolve(projectPath)) {
+            return { workspaceId: entry, folder };
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      // workspace dir not readable
+    }
+    return null;
+  }
+
+  function getCursorIdeState() {
+    if (!fs.existsSync(getIdeStatePath())) return null;
+    try {
+      return JSON.parse(fs.readFileSync(getIdeStatePath(), "utf8"));
+    } catch {
+      return null;
+    }
+  }
+
+  function getAiTrackingDbStats() {
+    if (!fs.existsSync(getAiTrackingDbPath())) return null;
+    const counts = {};
+    const tables = ["ai_code_hashes", "conversation_summaries", "scored_commits", "tracked_file_content", "ai_deleted_files"];
+    for (const table of tables) {
+      const rows = queryDb(getAiTrackingDbPath(), `SELECT COUNT(*) as count FROM ${table}`);
+      counts[table] = rows.length ? Number(rows[0].count) || 0 : 0;
+    }
+    return counts;
+  }
+
+  function analyzeCursorSessions(options = {}) {
+    const limit = options.limit || 20;
+    const cwd = options.cwd || process.cwd();
+
+    const composers = getCursorComposerHeaders();
+    const summaries = getCursorConversationSummaries(limit);
+    const scoredCommits = getCursorScoredCommits(limit);
+    const aiHashes = getCursorAiCodeHashes(limit);
+    const trackedFiles = getCursorTrackedFileContent(limit);
+    const deletedFiles = getCursorDeletedFiles(limit);
+    const dbStats = getAiTrackingDbStats();
+    const workspace = getCursorWorkspaceForProject(cwd);
+
+    const summaryMap = new Map();
+    for (const s of summaries) {
+      summaryMap.set(s.conversationId, s);
+    }
+
+    const sessions = composers
+      .sort((a, b) => b.createdAt - a.createdAt)
+      .slice(0, limit)
+      .map((composer) => {
+        const summary = summaryMap.get(composer.composerId);
+        return {
+          tool: "cursor",
+          sessionId: composer.composerId,
+          title: summary?.title || "",
+          tldr: summary?.tldr || "",
+          model: summary?.model || "",
+          mode: composer.mode || summary?.mode || "",
+          createdAt: composer.createdAt ? new Date(composer.createdAt).toISOString() : null,
+          updatedAt: summary?.updatedAt ? new Date(summary.updatedAt).toISOString() : null,
+          linesAdded: composer.linesAdded,
+          linesRemoved: composer.linesRemoved,
+          isArchived: composer.isArchived,
+          isDraft: composer.isDraft,
+          isWorktree: composer.isWorktree,
+          numSubComposers: composer.numSubComposers,
+          workspaceId: composer.workspaceId,
+          confidence: "cursor-metadata",
+        };
+      });
+
+    const totalLinesAdded = scoredCommits.reduce((sum, c) => sum + c.linesAdded, 0);
+    const totalComposerLinesAdded = scoredCommits.reduce((sum, c) => sum + c.composerLinesAdded, 0);
+    const totalTabLinesAdded = scoredCommits.reduce((sum, c) => sum + c.tabLinesAdded, 0);
+    const totalHumanLinesAdded = scoredCommits.reduce((sum, c) => sum + c.humanLinesAdded, 0);
+    const aiLinesAdded = totalComposerLinesAdded + totalTabLinesAdded;
+    const aiAuthorshipPercent = totalLinesAdded > 0 ? Math.round((aiLinesAdded / totalLinesAdded) * 100) : 0;
+
+    const modelDistribution = {};
+    for (const h of aiHashes) {
+      if (h.model) modelDistribution[h.model] = (modelDistribution[h.model] || 0) + 1;
+    }
+    const modeDistribution = {};
+    for (const c of composers) {
+      if (c.mode) modeDistribution[c.mode] = (modeDistribution[c.mode] || 0) + 1;
+    }
+
+    const aiGeneratedFiles = trackedFiles.map((f) => ({
+      gitPath: f.gitPath,
+      model: f.model,
+      contentLength: f.contentLength,
+      estimatedTokens: estimateTokens(f.contentLength),
+      createdAt: f.createdAt ? new Date(f.createdAt).toISOString() : null,
+    }));
+
+    const aiDeletedFileList = deletedFiles.map((f) => ({
+      gitPath: f.gitPath,
+      model: f.model,
+      deletedAt: f.deletedAt ? new Date(f.deletedAt).toISOString() : null,
+    }));
+
+    return {
+      generatedAt: new Date().toISOString(),
+      scannedPath: cwd,
+      tool: "cursor",
+      dbAvailable: fs.existsSync(getAiTrackingDbPath()),
+      sqlite3Available: isSqlite3Available(),
+      dbStats,
+      workspace,
+      sessions,
+      scoredCommits: scoredCommits.map((c) => ({
+        ...c,
+        scoredAt: c.scoredAt ? new Date(c.scoredAt).toISOString() : null,
+      })),
+      aiAuthorship: {
+        totalCommits: scoredCommits.length,
+        totalLinesAdded,
+        aiLinesAdded,
+        humanLinesAdded: totalHumanLinesAdded,
+        composerLinesAdded: totalComposerLinesAdded,
+        tabLinesAdded: totalTabLinesAdded,
+        aiAuthorshipPercent,
+      },
+      aiGeneratedFiles,
+      aiDeletedFiles: aiDeletedFileList,
+      modelDistribution,
+      modeDistribution,
+      totalSessions: composers.length,
+      activeSessions: composers.filter((c) => !c.isArchived).length,
+    };
+  }
+
+  function buildCursorSessionTimeline(cursorData) {
+    const events = [];
+
+    for (const commit of (cursorData.scoredCommits || []).slice(0, 10)) {
+      const aiLines = (commit.composerLinesAdded || 0) + (commit.tabLinesAdded || 0);
+      const totalLines = commit.linesAdded || 0;
+      const pct = totalLines > 0 ? Math.round((aiLines / totalLines) * 100) : 0;
+      if (totalLines > 0) {
+        events.push({
+          timestamp: commit.scoredAt || commit.commitDate || null,
+          type: pct >= 80 ? "high-ai-authorship" : pct >= 40 ? "mixed-authorship" : "human-authorship",
+          label: `Commit: ${(commit.commitMessage || commit.commitHash || "").slice(0, 60)}`,
+          detail: `+${totalLines}/-${commit.linesDeleted || 0} lines, ${pct}% AI (composer: ${commit.composerLinesAdded}, tab: ${commit.tabLinesAdded}, human: ${commit.humanLinesAdded})`,
+        });
+      }
+    }
+
+    for (const file of (cursorData.aiGeneratedFiles || []).slice(0, 5)) {
+      events.push({
+        timestamp: file.createdAt || null,
+        type: "ai-generated-file",
+        label: `AI-generated file tracked`,
+        detail: `${file.gitPath} (${file.model || "unknown model"}, ~${file.estimatedTokens} tokens)`,
+      });
+    }
+
+    for (const file of (cursorData.aiDeletedFiles || []).slice(0, 5)) {
+      events.push({
+        timestamp: file.deletedAt || null,
+        type: "ai-deleted-file",
+        label: `AI-generated file deleted`,
+        detail: `${file.gitPath} (${file.model || "unknown model"})`,
+      });
+    }
+
+    return events.sort((a, b) => {
+      const ta = a.timestamp ? new Date(a.timestamp).getTime() : 0;
+      const tb = b.timestamp ? new Date(b.timestamp).getTime() : 0;
+      return ta - tb;
+    }).slice(-20);
+  }
+
+  function buildCursorDiagnosis(cursorData) {
+    const drivers = [];
+    const recommendations = [];
+
+    const authorship = cursorData.aiAuthorship || {};
+    if (authorship.aiAuthorshipPercent >= 80) {
+      drivers.push({
+        type: "high-ai-authorship",
+        value: `${authorship.aiAuthorshipPercent}%`,
+        message: "Most committed code is AI-generated; review coverage may need extra attention.",
+      });
+    }
+    if (authorship.tabLinesAdded > authorship.composerLinesAdded && authorship.tabLinesAdded > 50) {
+      drivers.push({
+        type: "tab-completion-heavy",
+        value: `${authorship.tabLinesAdded} lines`,
+        message: "Tab completions contribute more code than composer/agent sessions.",
+      });
+    }
+
+    const totalSessions = cursorData.totalSessions || 0;
+    const activeSessions = cursorData.activeSessions || 0;
+    if (totalSessions > 50 && activeSessions > 40) {
+      drivers.push({
+        type: "session-accumulation",
+        value: `${totalSessions} total, ${activeSessions} active`,
+        message: "Many non-archived sessions; old context may accumulate.",
+      });
+      recommendations.push("Archive old Cursor composer sessions to reduce context clutter.");
+    }
+
+    const deletedCount = (cursorData.aiDeletedFiles || []).length;
+    const generatedCount = (cursorData.aiGeneratedFiles || []).length;
+    if (deletedCount > 3) {
+      drivers.push({
+        type: "ai-churn",
+        value: `${deletedCount} files deleted`,
+        message: "AI-generated files are being created and deleted, suggesting trial-and-error patterns.",
+      });
+      recommendations.push("Use context packs and firewall rules to scope AI tasks more precisely.");
+    }
+
+    if (generatedCount > 0) {
+      recommendations.push("Review AI-generated tracked files — some may be leaking into context.");
+    }
+    if (authorship.totalCommits > 0) {
+      recommendations.push("Use npx getprismo cursor authorship to track AI vs human code ratios over time.");
+    }
+    if (!recommendations.length) {
+      recommendations.push("npx getprismo doctor to optimize repo for Cursor sessions.");
+    }
+
+    return {
+      drivers: drivers.slice(0, 5),
+      recommendations: Array.from(new Set(recommendations)).slice(0, 4),
+    };
+  }
+
+  function renderCursorTerminal(cursorData, command) {
+    const lines = [];
+    lines.push("");
+    lines.push("Prismo Cursor Sessions");
+    lines.push("");
+
+    if (!cursorData.dbAvailable) {
+      lines.push("No Cursor AI tracking database found.");
+      lines.push("Cursor stores tracking data at ~/.cursor/ai-tracking/ai-code-tracking.db");
+      lines.push("Make sure Cursor is installed and has been used at least once.");
+      return lines.join("\n");
+    }
+    if (!cursorData.sqlite3Available) {
+      lines.push("sqlite3 command not found. Install sqlite3 to read Cursor tracking data.");
+      return lines.join("\n");
+    }
+
+    if (command === "list") {
+      lines.push(`Total sessions: ${cursorData.totalSessions}  (${cursorData.activeSessions} active)`);
+      lines.push(`Mode: ${Object.entries(cursorData.modeDistribution).map(([k, v]) => `${k}: ${v}`).join(", ") || "unknown"}`);
+      lines.push("");
+      const sessions = cursorData.sessions.slice(0, 15);
+      sessions.forEach((session, i) => {
+        const title = session.title ? ` "${session.title.slice(0, 50)}"` : "";
+        const model = session.model ? `  ${session.model}` : "";
+        lines.push(`${i + 1}. [${session.mode || "?"}]${title}${model}`);
+        lines.push(`   +${session.linesAdded}/-${session.linesRemoved}  ${session.createdAt || "unknown date"}${session.isArchived ? "  (archived)" : ""}`);
+      });
+      return lines.join("\n");
+    }
+
+    if (command === "authorship") {
+      const auth = cursorData.aiAuthorship;
+      lines.push("AI Authorship (from Cursor scored commits)");
+      lines.push("");
+      lines.push(`Commits analyzed: ${auth.totalCommits}`);
+      lines.push(`Total lines added: ${auth.totalLinesAdded}`);
+      lines.push("");
+      lines.push(`  Composer (agent):  ${auth.composerLinesAdded} lines`);
+      lines.push(`  Tab completions:   ${auth.tabLinesAdded} lines`);
+      lines.push(`  Human:             ${auth.humanLinesAdded} lines`);
+      lines.push("--------------------------------------------------");
+      lines.push(`  AI authorship:     ${auth.aiAuthorshipPercent}%`);
+      lines.push("");
+      if (cursorData.scoredCommits.length) {
+        lines.push("Recent commits:");
+        cursorData.scoredCommits.slice(0, 8).forEach((c) => {
+          const aiLines = (c.composerLinesAdded || 0) + (c.tabLinesAdded || 0);
+          const pct = c.linesAdded > 0 ? Math.round((aiLines / c.linesAdded) * 100) : 0;
+          const msg = (c.commitMessage || c.commitHash || "").slice(0, 50);
+          lines.push(`  ${pct}% AI  +${c.linesAdded}/-${c.linesDeleted}  ${msg}`);
+        });
+      }
+      return lines.join("\n");
+    }
+
+    if (command === "timeline") {
+      const timeline = buildCursorSessionTimeline(cursorData);
+      lines.push("Cursor Session Timeline");
+      lines.push("");
+      if (!timeline.length) {
+        lines.push("No timeline events found. Cursor needs scored commits or tracked files for timeline data.");
+      } else {
+        timeline.forEach((event) => {
+          const when = event.timestamp ? new Date(event.timestamp).toLocaleString() : "unknown";
+          lines.push(`${when}  [${event.type}]`);
+          lines.push(`  ${event.label}`);
+          lines.push(`  ${event.detail}`);
+          lines.push("");
+        });
+      }
+      const diagnosis = buildCursorDiagnosis(cursorData);
+      if (diagnosis.drivers.length) {
+        lines.push("Signals:");
+        diagnosis.drivers.forEach((d) => lines.push(`- ${d.message}`));
+      }
+      lines.push("");
+      lines.push("Suggested Actions:");
+      diagnosis.recommendations.forEach((r) => lines.push(`- ${r}`));
+      return lines.join("\n");
+    }
+
+    if (command === "files") {
+      lines.push("AI-Generated Files (tracked by Cursor)");
+      lines.push("");
+      if (!cursorData.aiGeneratedFiles.length && !cursorData.aiDeletedFiles.length) {
+        lines.push("No AI-generated files tracked yet.");
+        return lines.join("\n");
+      }
+      if (cursorData.aiGeneratedFiles.length) {
+        lines.push(`Tracked: ${cursorData.aiGeneratedFiles.length}`);
+        cursorData.aiGeneratedFiles.forEach((f) => {
+          lines.push(`  ${f.gitPath}  (${f.model || "?"}, ~${f.estimatedTokens} tokens)`);
+        });
+      }
+      if (cursorData.aiDeletedFiles.length) {
+        lines.push("");
+        lines.push(`Deleted: ${cursorData.aiDeletedFiles.length}`);
+        cursorData.aiDeletedFiles.forEach((f) => {
+          lines.push(`  ${f.gitPath}  (${f.model || "?"}, ${f.deletedAt || "?"})`);
+        });
+      }
+      return lines.join("\n");
+    }
+
+    // Default: summary view
+    lines.push(`Sessions: ${cursorData.totalSessions} total (${cursorData.activeSessions} active)`);
+    lines.push(`Modes: ${Object.entries(cursorData.modeDistribution).map(([k, v]) => `${k}: ${v}`).join(", ") || "none"}`);
+    if (Object.keys(cursorData.modelDistribution).length) {
+      lines.push(`Models: ${Object.entries(cursorData.modelDistribution).map(([k, v]) => `${k}: ${v}`).join(", ")}`);
+    }
+    lines.push("");
+    const auth = cursorData.aiAuthorship;
+    if (auth.totalCommits > 0) {
+      lines.push("AI Authorship");
+      lines.push(`  ${auth.totalCommits} commits analyzed, ${auth.aiAuthorshipPercent}% AI-authored`);
+      lines.push(`  Composer: ${auth.composerLinesAdded}  Tab: ${auth.tabLinesAdded}  Human: ${auth.humanLinesAdded} lines`);
+    } else {
+      lines.push("AI Authorship: no scored commits found yet");
+    }
+    lines.push("");
+
+    if (cursorData.aiGeneratedFiles.length) {
+      lines.push(`AI-generated files: ${cursorData.aiGeneratedFiles.length} tracked`);
+    }
+    if (cursorData.aiDeletedFiles.length) {
+      lines.push(`AI-deleted files: ${cursorData.aiDeletedFiles.length} (churn)`);
+    }
+    if (cursorData.dbStats) {
+      lines.push("");
+      lines.push("Tracking DB:");
+      lines.push(`  Code hashes: ${cursorData.dbStats.ai_code_hashes}  Conversations: ${cursorData.dbStats.conversation_summaries}  Commits: ${cursorData.dbStats.scored_commits}`);
+    }
+    lines.push("");
+    const diagnosis = buildCursorDiagnosis(cursorData);
+    if (diagnosis.drivers.length) {
+      lines.push("Signals:");
+      diagnosis.drivers.forEach((d) => lines.push(`- ${d.message}`));
+      lines.push("");
+    }
+    lines.push("Next:");
+    diagnosis.recommendations.slice(0, 3).forEach((r) => lines.push(`- ${r}`));
+    return lines.join("\n");
+  }
+
+  return {
+    analyzeCursorSessions,
+    buildCursorDiagnosis,
+    buildCursorSessionTimeline,
+    getAiTrackingDbStats,
+    getCursorAiCodeHashes,
+    getCursorComposerHeaders,
+    getCursorConversationSummaries,
+    getCursorDeletedFiles,
+    getCursorIdeState,
+    getCursorScoredCommits,
+    getCursorTrackedFileContent,
+    getCursorWorkspaceForProject,
+    isSqlite3Available,
+    renderCursorTerminal,
+  };
+};

package/lib/prismo-dev/mcp.js

@@ -31,6 +31,7 @@ function createMcpTools(deps) {
     toDoctorJsonPayload,
     getUsageSummary,
     getClaudeCodeCostSummary,
+    getCursorSessionSummary,
     runOptimize,
     createOptimizeContext,
     renderStarterPrompt,
@@ -106,6 +107,11 @@ function createMcpTools(deps) {
       path: pathProperty,
       limit: limitProperty,
     }),
+    makeTool("prismo_cursor_sessions", "Return Cursor session data including AI authorship, conversations, and AI-generated file tracking.", {
+      path: pathProperty,
+      limit: limitProperty,
+      command: { type: "string", enum: ["latest", "list", "authorship", "timeline", "files"], description: "Subcommand: latest (summary), list (sessions), authorship (AI%), timeline (events), files (AI-generated)." },
+    }),
   ];
 
   function resolveRoot(args) {
@@ -195,6 +201,15 @@ function createMcpTools(deps) {
       }));
     }
 
+    if (name === "prismo_cursor_sessions") {
+      if (!getCursorSessionSummary) throw new Error("Cursor session support not available");
+      return createTextResult(getCursorSessionSummary({
+        cwd: target,
+        limit: Number(args.limit) || 20,
+        mode: args.command || "latest",
+      }));
+    }
+
     throw new Error(`Unknown MCP tool: ${name}`);
   }
 
@@ -293,6 +308,7 @@ async function runMcpDoctor(deps) {
     "prismo_context_pack",
     "prismo_firewall",
     "prismo_cc_timeline",
+    "prismo_cursor_sessions",
   ];
   const toolNames = tools.map((tool) => tool.name);
   const missingTools = requiredTools.filter((name) => !toolNames.includes(name));

package/lib/prismo-dev/scan-detect.js

@@ -1,6 +1,14 @@
 module.exports = function createScanDetect(deps) {
   const { fs, http, https, os, path, readIfText, estimateTokens, getClaudeSessionFiles, getCodexSessionFiles, normalizeRel } = deps;
 
+  let cursorSessionsModule = null;
+  function getCursorModule() {
+    if (!cursorSessionsModule) {
+      cursorSessionsModule = require("./cursor-sessions")({ fs, os, path, estimateTokens });
+    }
+    return cursorSessionsModule;
+  }
+
   function countJsonObjectKeys(value, keyName) {
     if (!value || typeof value !== "object") return 0;
     let count = 0;
@@ -111,10 +119,11 @@ module.exports = function createScanDetect(deps) {
   function detectAgentReadiness(root, claudeConfig, codexConfig, realUsage) {
     const claudeHome = process.env.PRISMO_CLAUDE_HOME || path.join(os.homedir(), ".claude");
     const codexHome = process.env.PRISMO_CODEX_HOME || path.join(os.homedir(), ".codex");
+    const cursorHome = process.env.PRISMO_CURSOR_HOME || path.join(os.homedir(), ".cursor");
     const cursorPaths = [
       path.join(root, ".cursor"),
       path.join(root, ".cursorrules"),
-      path.join(os.homedir(), ".cursor"),
+      cursorHome,
       path.join(os.homedir(), ".config", "Cursor"),
     ];
     const usageSources = new Set(realUsage && realUsage.sources ? realUsage.sources : []);
@@ -140,13 +149,26 @@ module.exports = function createScanDetect(deps) {
         exactProxyTracking: "available-when-using-api-key-base-url-mode",
         recommendedMode: "prismo-proxy-for-api-mode-or-local-log-watch",
       },
-      cursor: {
-        detected: pathExistsAny(cursorPaths),
-        configFiles: cursorPaths.filter((candidate) => fs.existsSync(candidate)),
-        localLogsFound: false,
-        exactProxyTracking: "available-only-if-configured-for-openai-compatible-base-url",
-        recommendedMode: "repo-scan-and-prismo-proxy-when-supported",
-      },
+      cursor: (() => {
+        const detected = pathExistsAny(cursorPaths);
+        const cursorMod = getCursorModule();
+        const dbAvailable = cursorMod.isSqlite3Available() && fs.existsSync(path.join(cursorHome, "ai-tracking", "ai-code-tracking.db"));
+        const dbStats = dbAvailable ? cursorMod.getAiTrackingDbStats() : null;
+        const workspace = detected ? cursorMod.getCursorWorkspaceForProject(root) : null;
+        const composers = dbAvailable ? cursorMod.getCursorComposerHeaders() : [];
+        return {
+          detected,
+          configFiles: cursorPaths.filter((candidate) => fs.existsSync(candidate)),
+          localLogsFound: dbAvailable && (dbStats ? (dbStats.ai_code_hashes + dbStats.scored_commits + dbStats.conversation_summaries) > 0 : false),
+          dbAvailable,
+          dbStats,
+          workspace,
+          totalSessions: composers.length,
+          activeSessions: composers.filter((c) => !c.isArchived).length,
+          exactProxyTracking: "available-only-if-configured-for-openai-compatible-base-url",
+          recommendedMode: dbAvailable ? "cursor-tracking-db-and-repo-scan" : "repo-scan-and-prismo-proxy-when-supported",
+        };
+      })(),
       localUsageLogsAvailable: Boolean((realUsage && realUsage.sessions.length) || claudeSessionFiles.length || codexSessionFiles.length),
       exactProxyTrackingAvailable: true,
       notes: [

package/lib/prismo-dev/scan.js

@@ -20,6 +20,7 @@ module.exports = function createScan(deps) {
     getCodexSessionFiles,
     compactUsageSummary,
     formatTokenCount,
+    color,
   } = deps;
 
 const {
@@ -229,7 +230,11 @@ function renderSetupTerminal(result) {
   lines.push("Detected:");
   lines.push(`- Claude Code: ${result.detected.claudeCode.detected ? "detected" : "not detected"}; logs: ${result.detected.claudeCode.localLogsFound ? "found" : "not found"}; MCP: ${result.detected.claudeCode.mcpServers}; hooks: ${result.detected.claudeCode.hooks}`);
   lines.push(`- Codex: ${result.detected.codex.detected ? "detected" : "not detected"}; logs: ${result.detected.codex.localLogsFound ? "found" : "not found"}; MCP: ${result.detected.codex.mcpServers}`);
-  lines.push(`- Cursor: ${result.detected.cursor.detected ? "detected" : "not detected"}`);
+  const cursorInfo = result.detected.cursor;
+  lines.push(`- Cursor: ${cursorInfo.detected ? "detected" : "not detected"}${cursorInfo.dbAvailable ? `; tracking DB: found (${cursorInfo.totalSessions} sessions, ${cursorInfo.activeSessions} active)` : ""}${cursorInfo.workspace ? `; workspace: matched` : ""}`);
+  if (cursorInfo.dbStats) {
+    lines.push(`  Tracking: ${cursorInfo.dbStats.scored_commits} scored commits, ${cursorInfo.dbStats.ai_code_hashes} code hashes, ${cursorInfo.dbStats.conversation_summaries} conversation summaries`);
+  }
   const detectedTools = result.detected.optimizationStack.detectedTools;
   lines.push(`- Optimization tools: ${detectedTools.length ? detectedTools.join(", ") : "none detected"}`);
   lines.push("");
@@ -562,6 +567,31 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
   }
   const optimizationStack = detectOptimizationStack(root, claudeConfig, codexConfig);
   const agentReadiness = detectAgentReadiness(root, claudeConfig, codexConfig, realUsage);
+
+  if (agentReadiness.cursor.dbAvailable) {
+    try {
+      const cursorMod = require("./cursor-sessions")({ fs, os, path, estimateTokens });
+      const tracked = cursorMod.getCursorTrackedFileContent(20);
+      const cursorAiFiles = tracked.filter((f) => {
+        const fullPath = path.join(root, f.gitPath);
+        return fs.existsSync(fullPath);
+      });
+      if (cursorAiFiles.length >= 3) {
+        addIssue(
+          issues,
+          "medium",
+          "ai_generated_files",
+          `${cursorAiFiles.length} AI-generated files still in repo (tracked by Cursor)`,
+          cursorAiFiles.slice(0, 5).map((f) => `${f.gitPath} (${f.model || "unknown model"})`).join(", "),
+          "Review AI-generated files for quality and whether they should remain in the project.",
+          `AI-generated content may inflate context if agents re-read it. Run: npx getprismo cursor files`
+        );
+      }
+    } catch {
+      // Cursor data unavailable
+    }
+  }
+
   const toolOutputRisk = detectToolOutputRisk({ exposedLargeFiles, exposedHighRiskDirs, highRiskDirs });
   const operationalNoise = detectOperationalNoise(files);
   const proxyTrackingReadiness = buildProxyTrackingReadiness({ codexConfig, claudeConfig, realUsage });

package/lib/prismo-dev/usage-sessions.js

@@ -9,6 +9,10 @@ module.exports = function createUsageSessions(deps) {
     readIfText,
   } = deps;
 
+  const {
+    analyzeCursorSessions,
+  } = require("./cursor-sessions")({ fs, os, path, estimateTokens });
+
   const {
     addUsage,
     collectText,
@@ -261,6 +265,69 @@ function getUsageSummary(options = {}) {
       sessions.push(analyzeSessionFile(file, "claude-code"));
     }
   }
+  if (tool === "all" || tool === "cursor") {
+    try {
+      const cursorData = analyzeCursorSessions({ limit, cwd });
+      if (cursorData.sessions.length) {
+        for (const cursorSession of cursorData.sessions.slice(0, limit)) {
+          sessions.push({
+            tool: "cursor",
+            filePath: null,
+            sessionId: cursorSession.sessionId,
+            title: cursorSession.title,
+            cwd: cwd,
+            model: cursorSession.model,
+            startedAt: cursorSession.createdAt,
+            updatedAt: cursorSession.updatedAt || cursorSession.createdAt,
+            turns: 0,
+            userMessages: 0,
+            assistantMessages: 0,
+            toolCalls: 0,
+            toolResults: 0,
+            estimatedInputTokens: 0,
+            estimatedOutputTokens: 0,
+            estimatedToolTokens: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            exactInputTokens: 0,
+            exactOutputTokens: 0,
+            exactCacheReadTokens: 0,
+            exactCacheCreationTokens: 0,
+            exactTotalTokens: 0,
+            exactAvailable: false,
+            confidence: "cursor-metadata",
+            largestTextBlobs: [],
+            toolNames: {},
+            pathMentions: {},
+            generatedArtifactMentions: {},
+            commandMentions: {},
+            failureMentions: 0,
+            eventTokenDeltas: [],
+            exactTokenTimeline: [],
+            estimatedTotalTokens: 0,
+            exactActiveTokens: 0,
+            contextTokens: 0,
+            displayTokens: 0,
+            contextRisk: "Low",
+            recentContextGrowth: 0,
+            repeatedPathMentions: [],
+            generatedArtifacts: [],
+            repeatedCommands: [],
+            loopSuspicion: false,
+            loopConfidence: "low",
+            cost: null,
+            cursorMode: cursorSession.mode,
+            cursorLinesAdded: cursorSession.linesAdded,
+            cursorLinesRemoved: cursorSession.linesRemoved,
+          });
+        }
+      }
+    } catch {
+      // Cursor data unavailable
+    }
+  }
   sessions.sort((a, b) => new Date(b.updatedAt || 0) - new Date(a.updatedAt || 0));
   const selected = sessions.slice(0, limit);
   const totals = selected.reduce(
@@ -290,6 +357,7 @@ function getUsageSummary(options = {}) {
 
   return {
     analyzeSessionFile,
+    analyzeCursorSessions,
     getAllClaudeSessionFiles,
     getClaudeSessionFiles,
     getCodexSessionFiles,

package/lib/prismo-dev/usage-watch.js

@@ -63,6 +63,7 @@ const {
 
 const {
   analyzeSessionFile,
+  analyzeCursorSessions,
   getAllClaudeSessionFiles,
   getClaudeSessionFiles,
   getCodexSessionFiles,
@@ -77,6 +78,12 @@ const {
   readIfText,
 });
 
+const {
+  buildCursorDiagnosis,
+  buildCursorSessionTimeline,
+  renderCursorTerminal,
+} = require("./cursor-sessions")({ fs, os, path, estimateTokens });
+
 function getUsageSummary(options = {}) {
   const summary = getBaseUsageSummary(options);
   if ((summary.sessions || []).length > 1) {
@@ -176,6 +183,17 @@ function getClaudeCodeCostSummary(options = {}) {
   };
 }
 
+function getCursorSessionSummary(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const limit = options.limit || 20;
+  const mode = options.mode || "latest";
+  const cursorData = analyzeCursorSessions({ limit, cwd });
+  cursorData.command = mode;
+  cursorData.timeline = buildCursorSessionTimeline(cursorData);
+  cursorData.diagnosis = buildCursorDiagnosis(cursorData);
+  return cursorData;
+}
+
 function parsePositiveInt(value, fallback) {
   const parsed = Number.parseInt(value, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -550,6 +568,9 @@ async function watchUsage(options = {}) {
 
   return {
     analyzeSessionFile,
+    analyzeCursorSessions,
+    buildCursorDiagnosis,
+    buildCursorSessionTimeline,
     calculateClaudeCost,
     compactUsageSummary,
     formatMoney,
@@ -557,11 +578,13 @@ async function watchUsage(options = {}) {
     getClaudeCodeCostSummary,
     getClaudeSessionFiles,
     getCodexSessionFiles,
+    getCursorSessionSummary,
     getUsageSummary,
     getPositionals,
     parsePositiveInt,
     parseScopeAndTarget,
     renderClaudeCostTerminal,
+    renderCursorTerminal,
     renderUsageTerminal,
     renderContextThrottle,
     buildWatchEvent,

package/lib/prismo-dev-scan.js

@@ -53,6 +53,9 @@ const {
 
 const {
   analyzeSessionFile,
+  analyzeCursorSessions,
+  buildCursorDiagnosis,
+  buildCursorSessionTimeline,
   calculateClaudeCost,
   compactUsageSummary,
   formatMoney,
@@ -60,11 +63,13 @@ const {
   getClaudeCodeCostSummary,
   getClaudeSessionFiles,
   getCodexSessionFiles,
+  getCursorSessionSummary,
   getUsageSummary,
   getPositionals,
   parsePositiveInt,
   parseScopeAndTarget,
   renderClaudeCostTerminal,
+  renderCursorTerminal,
   renderUsageTerminal,
   renderContextThrottle,
   renderRescuePrompt,
@@ -112,6 +117,7 @@ const scanApi = require("./prismo-dev/scan")({
   getCodexSessionFiles,
   compactUsageSummary,
   formatTokenCount,
+  color,
 });
 
 ({ scanRepo } = scanApi);
@@ -265,8 +271,9 @@ Usage:
   prismo optimize [scope] [--json] [path]
   prismo context [scope] [--json] [path]
   prismo cc [list|last N|all|timeline] [--json] [--limit N] [--firewall] [--task TASK] [path]
-  prismo usage [codex|claude|all] [--json] [--limit N] [path]
-  prismo watch [codex|claude|all] [--json] [--once] [--agents] [--report] [--rescue] [--guardrails] [--throttle] [--events] [--no-events] [--auto] [--budget N] [--redact-paths] [--interval N] [path]
+  prismo cursor [list|authorship|timeline|files|all] [--json] [--limit N] [path]
+  prismo usage [codex|claude|cursor|all] [--json] [--limit N] [path]
+  prismo watch [codex|claude|cursor|all] [--json] [--once] [--agents] [--report] [--rescue] [--guardrails] [--throttle] [--events] [--no-events] [--auto] [--budget N] [--redact-paths] [--interval N] [path]
   prismo demo
 
 Commands:
@@ -281,7 +288,8 @@ Commands:
   optimize    Generate lightweight AI-readable project context files in .prismo/.
   context     Print a copy-pasteable compact context prompt for AI coding tools.
   cc          Show Claude Code token cost, cache cost, and all-time totals.
-  usage       Read local Codex/Claude Code session logs and summarize token usage.
+  cursor      Show Cursor session data, AI authorship, and AI-generated file tracking.
+  usage       Read local Codex/Claude Code/Cursor session logs and summarize token usage.
   watch       Refresh local session usage in the terminal.
   demo        Show sample output without needing a messy repo.
   setup       Detect coding tools, tracking modes, local logs, and Prismo proxy readiness.
@@ -399,22 +407,45 @@ Examples:
   timeline shows context spikes, repeated commands, artifact leaks, and tool-output pressure for the latest session.
   --firewall writes .prismo/timeline-firewall-suggestions.md and suggested allow/block files from timeline evidence.
   Without a path, cc commands read all Claude Code projects. Passing a path filters to that project.`,
+    cursor: `Prismo Cursor Sessions
+
+Usage:
+  prismo cursor [--json] [--limit N] [path]
+  prismo cursor list [--json] [--limit N] [path]
+  prismo cursor authorship [--json] [--limit N] [path]
+  prismo cursor timeline [--json] [--limit N] [path]
+  prismo cursor files [--json] [--limit N] [path]
+  prismo cursor all [--json] [--limit N] [path]
+
+Examples:
+  prismo cursor
+  prismo cursor authorship
+  prismo cursor list --limit 20
+  prismo cursor timeline --json
+  prismo cursor files
+
+Output:
+  Reads ~/.cursor/ai-tracking/ai-code-tracking.db and Cursor workspace state databases.
+  Shows Cursor composer sessions, AI authorship percentages from scored commits, AI-generated file tracking, and churn analysis.
+  Requires sqlite3 to be installed on the system.`,
     usage: `Prismo Usage
 
 Usage:
-  prismo usage [codex|claude|all] [--json] [--limit N] [path]
+  prismo usage [codex|claude|cursor|all] [--json] [--limit N] [path]
 
 Examples:
   prismo usage
   prismo usage codex --json
+  prismo usage cursor
   prismo usage claude --limit 3`,
     watch: `Prismo Watch
 
 Usage:
-  prismo watch [codex|claude|all] [--json] [--once] [--agents] [--report] [--rescue] [--guardrails] [--throttle] [--events] [--no-events] [--auto] [--budget N] [--redact-paths] [--interval N] [path]
+  prismo watch [codex|claude|cursor|all] [--json] [--once] [--agents] [--report] [--rescue] [--guardrails] [--throttle] [--events] [--no-events] [--auto] [--budget N] [--redact-paths] [--interval N] [path]
 
 Examples:
   prismo watch codex
+  prismo watch cursor --once --json
   prismo watch claude --once --json
   prismo watch --agents --once
   prismo watch --once --report
@@ -519,6 +550,7 @@ Tools exposed:
   prismo_context_pack
   prismo_firewall
   prismo_cc_timeline
+  prismo_cursor_sessions
 
 Output:
   Starts a local JSON-RPC MCP server over stdio. Use it from MCP-compatible clients so agents can scan context waste, search shielded command output, and request scoped context without loading huge logs into chat.
@@ -574,8 +606,8 @@ async function runCli(argv) {
     printCommandHelp(command);
     return;
   }
-  if (!["dev", "init", "doctor", "firewall", "benchmark", "shield", "mcp", "setup", "scan", "optimize", "context", "cc", "usage", "watch", "demo"].includes(command)) {
-    throw new Error(`Unknown command: ${command}. Try: prismo doctor, prismo watch, prismo benchmark, prismo shield, prismo mcp, prismo firewall, prismo init, prismo scan, prismo optimize, prismo context, prismo cc, or prismo usage`);
+  if (!["dev", "init", "doctor", "firewall", "benchmark", "shield", "mcp", "setup", "scan", "optimize", "context", "cc", "cursor", "usage", "watch", "demo"].includes(command)) {
+    throw new Error(`Unknown command: ${command}. Try: prismo doctor, prismo watch, prismo benchmark, prismo shield, prismo mcp, prismo firewall, prismo init, prismo scan, prismo optimize, prismo context, prismo cc, prismo cursor, or prismo usage`);
   }
 
   if (command === "demo") {
@@ -725,6 +757,7 @@ async function runCli(argv) {
       toDoctorJsonPayload,
       getUsageSummary,
       getClaudeCodeCostSummary,
+      getCursorSessionSummary,
       runOptimize,
       createOptimizeContext,
       renderStarterPrompt,
@@ -839,9 +872,31 @@ async function runCli(argv) {
     return;
   }
 
+  if (command === "cursor") {
+    const json = rest.includes("--json");
+    const limitIndex = rest.indexOf("--limit");
+    const positional = getPositionals(rest, new Set(["--limit"]));
+    const subcommand = positional[0] && ["list", "authorship", "timeline", "files", "all"].includes(positional[0].toLowerCase())
+      ? positional[0].toLowerCase()
+      : "latest";
+    const target = (subcommand !== "latest" ? positional[1] : positional[0]) || process.cwd();
+    const limit = parsePositiveInt(limitIndex >= 0 ? rest[limitIndex + 1] : null, subcommand === "all" ? 200 : 20);
+    const summary = getCursorSessionSummary({
+      cwd: path.resolve(target),
+      limit,
+      mode: subcommand,
+    });
+    if (json) {
+      console.log(JSON.stringify(summary, null, 2));
+      return;
+    }
+    console.log(renderCursorTerminal(summary, subcommand));
+    return;
+  }
+
   if (command === "usage" || command === "watch") {
     const json = rest.includes("--json");
-    const knownTools = new Set(["codex", "claude", "all"]);
+    const knownTools = new Set(["codex", "claude", "cursor", "all"]);
     const positional = getPositionals(rest, new Set(["--limit", "--interval", "--budget"]));
     const explicitTool = positional[0] && knownTools.has(positional[0].toLowerCase());
     const tool = explicitTool ? positional[0].toLowerCase() : "all";
@@ -1021,6 +1076,7 @@ module.exports = {
   renderMarkdownReport,
   renderSimpleScanReport,
   renderClaudeCostTerminal,
+  renderCursorTerminal,
   renderUsageTerminal,
   renderContextThrottle,
   renderRescuePrompt,
@@ -1040,7 +1096,9 @@ module.exports = {
   runCli,
   scanRepo,
   getClaudeCodeCostSummary,
+  getCursorSessionSummary,
   getUsageSummary,
+  analyzeCursorSessions,
   analyzeSessionFile,
   calculateClaudeCost,
   toDoctorJsonPayload,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getprismo",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "Local AI coding workflow scanner for Codex, Claude Code, Cursor, and token-waste diagnostics.",
   "license": "MIT",
   "homepage": "https://github.com/shanirsh/prismodev#readme",