codiedev 0.5.5 → 0.6.0

package/dist/cli.js

@@ -19,6 +19,7 @@ const connect_1 = require("./connect");
 const push_1 = require("./commands/push");
 const delete_1 = require("./commands/delete");
 const pull_1 = require("./commands/pull");
+const ask_1 = require("./commands/ask");
 const ping_1 = require("./commands/ping");
 const inbox_1 = require("./commands/inbox");
 const note_1 = require("./commands/note");
@@ -43,6 +44,10 @@ Artifacts:
   codiedev delete <key> [-y]             Delete every version of an artifact you
                                          authored (clean up bad/test pushes).
                                          Asks for confirmation; -y to skip.
+  codiedev ask "<question>"              Ask a natural-language question of the
+                                         team's collective memory. Returns an
+                                         LLM-synthesized answer with citations
+                                         pointing at sessions + artifacts.
   codiedev promote <artifact-id>         Promote an auto-extracted artifact
                                          to an authored one
   codiedev reverse-ticket [<pr-url>]     Generate a Jira ticket draft.
@@ -374,6 +379,9 @@ async function main() {
             case "pull":
                 await (0, pull_1.runPull)(rest);
                 return;
+            case "ask":
+                await (0, ask_1.runAsk)(rest);
+                return;
             case "ping":
                 await (0, ping_1.runPing)(rest);
                 return;

package/dist/commands/ask.d.ts

@@ -0,0 +1 @@
+export declare function runAsk(args: string[]): Promise<void>;

package/dist/commands/ask.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAsk = runAsk;
+const shared_1 = require("./shared");
+function parseArgs(args) {
+    // Everything after the command, joined back into a question string. Allows
+    // both quoted and unquoted forms: `codiedev ask "why pg-bouncer?"` or
+    // `codiedev ask why did we drop pg-bouncer`.
+    const question = args
+        .filter((a) => !a.startsWith("--"))
+        .join(" ")
+        .trim();
+    if (!question) {
+        console.error('Usage: codiedev ask "<question>"');
+        console.error('Example: codiedev ask "why did we drop pg-bouncer?"');
+        process.exit(1);
+    }
+    return { question };
+}
+async function runAsk(args) {
+    const { question } = parseArgs(args);
+    const config = (0, shared_1.requireConfig)();
+    try {
+        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/ask", {
+            config,
+            body: { question },
+        });
+        console.log("");
+        console.log(res.answer);
+        if (res.citations.length > 0) {
+            console.log("");
+            console.log("Sources:");
+            for (const c of res.citations) {
+                const label = c.kind === "artifact"
+                    ? `[${c.type}] ${c.title}`
+                    : `[session] ${c.title}`;
+                console.log(`  • ${label}`);
+            }
+        }
+        console.log("");
+    }
+    catch (err) {
+        console.error(`Ask failed: ${err.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/doctor.js

@@ -44,6 +44,9 @@ const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json")
 const CLAUDE_INSTRUCTIONS_PATH = path.join(os.homedir(), ".claude", "CLAUDE.md");
 const CODEX_HOOKS_PATH = path.join(os.homedir(), ".codex", "hooks.json");
 const CODEX_INSTRUCTIONS_PATH = path.join(os.homedir(), ".codex", "AGENTS.md");
+const CURSOR_HOOKS_PATH = path.join(os.homedir(), ".cursor", "hooks.json");
+const CURSOR_INSTRUCTIONS_PATH = path.join(os.homedir(), ".cursor", "rules", "codiedev.mdc");
+const CURSOR_MCP_PATH = path.join(os.homedir(), ".cursor", "mcp.json");
 function symbol(status) {
     if (status === "pass")
         return "✓";
@@ -57,6 +60,43 @@ function claudeCodeInstalled() {
 function codexInstalled() {
     return fs.existsSync(path.join(os.homedir(), ".codex"));
 }
+function cursorInstalled() {
+    return fs.existsSync(path.join(os.homedir(), ".cursor"));
+}
+function hasCursorMcpEntry() {
+    try {
+        if (!fs.existsSync(CURSOR_MCP_PATH))
+            return false;
+        const raw = fs.readFileSync(CURSOR_MCP_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        const servers = parsed.mcpServers;
+        return !!servers && "codiedev" in servers;
+    }
+    catch {
+        return false;
+    }
+}
+// Cursor's hooks.json schema is { hooks: { sessionEnd: [{ command, ... }] } }
+// — flat array of objects with `command`, not the Claude/Codex nested
+// `{ hooks: [{ command }] }` wrapper.
+function hasCursorHook() {
+    try {
+        if (!fs.existsSync(CURSOR_HOOKS_PATH))
+            return false;
+        const raw = fs.readFileSync(CURSOR_HOOKS_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        const arr = parsed.hooks?.sessionEnd;
+        if (!Array.isArray(arr))
+            return false;
+        return arr.some((h) => {
+            const cmd = h.command;
+            return (cmd ?? "").includes("codiedev-hook");
+        });
+    }
+    catch {
+        return false;
+    }
+}
 function hasCodiedevHook(settingsPath, hookKey) {
     try {
         if (!fs.existsSync(settingsPath))
@@ -229,7 +269,43 @@ async function runDoctor(_args) {
             detail: "not installed on this machine",
         });
     }
-    // 7. gh CLI (optional — only needed for reverse-ticket)
+    // 7. Cursor setup (if present)
+    if (cursorInstalled()) {
+        checks.push({
+            name: "Cursor detected",
+            status: "pass",
+            detail: "~/.cursor",
+        });
+        checks.push({
+            name: "Cursor sessionEnd hook",
+            status: hasCursorHook() ? "pass" : "fail",
+            detail: hasCursorHook()
+                ? "~/.cursor/hooks.json"
+                : "missing — re-run `codiedev connect`",
+        });
+        checks.push({
+            name: "Cursor agent instructions",
+            status: hasCodiedevInstructions(CURSOR_INSTRUCTIONS_PATH) ? "pass" : "fail",
+            detail: hasCodiedevInstructions(CURSOR_INSTRUCTIONS_PATH)
+                ? "~/.cursor/rules/codiedev.mdc"
+                : "missing — re-run `codiedev connect`",
+        });
+        checks.push({
+            name: "Cursor MCP server",
+            status: hasCursorMcpEntry() ? "pass" : "fail",
+            detail: hasCursorMcpEntry()
+                ? "~/.cursor/mcp.json"
+                : "missing — re-run `codiedev connect`",
+        });
+    }
+    else {
+        checks.push({
+            name: "Cursor",
+            status: "warn",
+            detail: "not installed on this machine",
+        });
+    }
+    // 8. gh CLI (optional — only needed for reverse-ticket)
     checks.push({
         name: "GitHub CLI (`gh`) for reverse-ticket command",
         status: hasGhCli() ? "pass" : "warn",

package/dist/connect.js

@@ -141,6 +141,7 @@ async function runConnect() {
     }
     const hasClaude = (0, utils_1.claudeCodeInstalled)();
     const hasCodex = (0, utils_1.codexInstalled)();
+    const hasCursor = (0, utils_1.cursorInstalled)();
     const installed = [];
     if (hasClaude) {
         try {
@@ -157,6 +158,13 @@ async function runConnect() {
         catch (err) {
             console.error(`\nWarning: Failed to install Claude Code instructions — ${err.message}`);
         }
+        try {
+            (0, utils_1.installClaudeCodeMcp)();
+            installed.push("Claude Code MCP server (~/.claude.json)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Claude Code MCP server — ${err.message}`);
+        }
     }
     if (hasCodex) {
         try {
@@ -173,9 +181,39 @@ async function runConnect() {
         catch (err) {
             console.error(`\nWarning: Failed to install Codex instructions — ${err.message}`);
         }
+        try {
+            (0, utils_1.installCodexMcp)();
+            installed.push("Codex MCP server (~/.codex/config.toml)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Codex MCP server — ${err.message}`);
+        }
+    }
+    if (hasCursor) {
+        try {
+            (0, utils_1.installCursorHook)();
+            installed.push("Cursor sessionEnd hook (~/.cursor/hooks.json)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Cursor hook — ${err.message}`);
+        }
+        try {
+            (0, utils_1.installCursorInstructions)();
+            installed.push("Cursor agent instructions (~/.cursor/rules/codiedev.mdc)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Cursor instructions — ${err.message}`);
+        }
+        try {
+            (0, utils_1.installCursorMcp)();
+            installed.push("Cursor MCP server (~/.cursor/mcp.json)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Cursor MCP server — ${err.message}`);
+        }
     }
-    if (!hasClaude && !hasCodex) {
-        console.warn("\nNo Claude Code (~/.claude) or Codex (~/.codex) install detected.");
+    if (!hasClaude && !hasCodex && !hasCursor) {
+        console.warn("\nNo Claude Code (~/.claude), Codex (~/.codex), or Cursor (~/.cursor) install detected.");
         console.warn("Config saved. Install one, then re-run `npx codiedev connect` to wire up capture hooks.");
     }
     console.log(`\nConnected to ${companyName}`);

package/dist/hook.js

@@ -87,6 +87,8 @@ async function readStdin() {
 function resolveMode(arg) {
     if (arg === "capture-codex")
         return "codex";
+    if (arg === "capture-cursor")
+        return "cursor";
     return "claude-code";
 }
 async function main() {
@@ -101,7 +103,10 @@ async function main() {
     catch {
         process.exit(0);
     }
-    const { session_id, transcript_path, cwd } = hookInput;
+    const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
+    const workspaceRoot = workspace_roots && workspace_roots.length > 0
+        ? workspace_roots[0]
+        : cwd || process.cwd();
     const config = (0, utils_1.readConfig)();
     if (!config) {
         process.exit(0);
@@ -116,13 +121,14 @@ async function main() {
     catch {
         process.exit(0);
     }
-    // Resolve repo URL. Codex embeds it in session_meta; fall back to git for CC.
+    // Resolve repo URL. Codex embeds it in session_meta; CC and Cursor both
+    // need the git remote of the workspace.
     let remoteUrl = null;
     if (mode === "codex") {
         remoteUrl = (0, utils_1.extractCodexRepoUrl)(transcriptContent);
     }
     if (!remoteUrl) {
-        remoteUrl = (0, utils_1.getGitRemoteUrl)(cwd || process.cwd());
+        remoteUrl = (0, utils_1.getGitRemoteUrl)(workspaceRoot);
     }
     if (!remoteUrl) {
         process.exit(0);
@@ -131,9 +137,14 @@ async function main() {
     if (!matchedRepo) {
         process.exit(0);
     }
+    // Cursor's transcript format is undocumented — skip stats parsing for now
+    // and let the backend handle it once we have a real session to inspect.
+    // The transcript itself still uploads.
     const stats = mode === "codex"
         ? (0, utils_1.parseCodexStats)(transcriptContent)
-        : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
+        : mode === "cursor"
+            ? { messageCount: 0, toolCallCount: 0 }
+            : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
     const payload = {
         sessionId: session_id,

package/dist/mcp.js

@@ -384,7 +384,9 @@ const TOOLS = [
             "when the user asks 'has anyone solved X?', 'find me the spec on Y', " +
             "or 'look for prior work on Z'. Always search before pushing a new " +
             "artifact so the user doesn't duplicate work. Returns ranked hits " +
-            "with title, type, filename key, and a snippet.",
+            "with title, type, filename key, and a snippet. For open-ended " +
+            "questions where the user wants a synthesized answer (not just a list " +
+            "of hits), prefer codiedev_ask instead.",
         inputSchema: {
             type: "object",
             properties: {
@@ -394,6 +396,32 @@ const TOOLS = [
             required: ["query"],
         },
     },
+    {
+        name: "codiedev_ask",
+        description: "Ask a natural-language question of the team's collective memory and " +
+            "get a synthesized answer with citations. Searches across both " +
+            "auto-extracted artifacts (specs / decisions / bugfixes) AND raw " +
+            "session transcripts, then has an LLM compose an answer that cites " +
+            "the actual sources. Use when the user asks 'why did we…?', 'what " +
+            "does the team know about X?', 'has anyone done Y here before?', " +
+            "'who decided Z and why?', or any open-ended question about prior " +
+            "work where they want context, not just a hit list. For exact-match " +
+            "lookups (find me spec-x), prefer codiedev_pull. For browsing or " +
+            "filtering by kind/tag, prefer codiedev_get_library. For surfacing " +
+            "ranked hits without LLM synthesis, prefer codiedev_search.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                question: {
+                    type: "string",
+                    description: "Natural-language question. Open-ended is fine — e.g. 'why " +
+                        "did we drop pg-bouncer?' or 'how does the team think about " +
+                        "feature flags?'.",
+                },
+            },
+            required: ["question"],
+        },
+    },
     {
         name: "codiedev_get_library",
         description: "List artifacts in the team library — both docs (spec / decision / " +
@@ -571,6 +599,8 @@ async function dispatchTool(name, args, config) {
             return await handleSendTo(args, config);
         case "codiedev_react":
             return await handleReact(args, config);
+        case "codiedev_ask":
+            return await handleAsk(args, config);
         case "codiedev_search":
             return await handleSearch(args, config);
         case "codiedev_get_library":
@@ -922,6 +952,23 @@ async function handleSearch(args, config) {
     }
     return { content: [{ type: "text", text: lines.join("\n") }] };
 }
+async function handleAsk(args, config) {
+    const question = asString(args.question);
+    if (!question)
+        throw new Error("question required");
+    const res = await (0, shared_1.apiRequest)("POST", "/api/cli/ask", { config, body: { question } });
+    const lines = [res.answer];
+    if (res.citations && res.citations.length > 0) {
+        lines.push("", "Sources:");
+        for (const c of res.citations) {
+            const label = c.kind === "artifact"
+                ? `[${c.type}] ${c.title}`
+                : `[session] ${c.title}`;
+            lines.push(`  • ${label}`);
+        }
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+}
 async function handleGetLibrary(args, config) {
     const scope = asStringOrUndefined(args.scope);
     const type = asStringOrUndefined(args.type);

package/dist/utils.d.ts

@@ -26,14 +26,23 @@ export declare function matchRepo(remoteUrl: string, repos: Array<{
 export declare function hashToken(token: string): string;
 export declare function claudeCodeInstalled(): boolean;
 export declare function codexInstalled(): boolean;
+export declare function cursorInstalled(): boolean;
 export declare function installHook(): void;
 export declare function installClaudeCodeInstructions(): void;
 export declare function installCodexInstructions(): void;
+export declare function installCursorInstructions(): void;
 /**
  * Install the CodieDev MCP server into Claude Code's user-scope config.
  * Safe to call multiple times — updates the existing entry if present.
  */
 export declare function installClaudeCodeMcp(): void;
+/**
+ * Install the CodieDev MCP server into Cursor's user-scope config.
+ * Cursor uses the same `mcpServers` schema as Claude Code; just a different
+ * file path (~/.cursor/mcp.json). Project-scoped servers can also live at
+ * <project>/.cursor/mcp.json — we only manage the user-scope one.
+ */
+export declare function installCursorMcp(): void;
 /**
  * Best-effort append of the CodieDev MCP server block to ~/.codex/config.toml.
  *
@@ -42,6 +51,7 @@ export declare function installClaudeCodeMcp(): void;
  */
 export declare function installCodexMcp(): boolean;
 export declare function installCodexHook(): void;
+export declare function installCursorHook(): void;
 export interface ParsedStats {
     messageCount: number;
     toolCallCount: number;

package/dist/utils.js

@@ -41,12 +41,16 @@ exports.matchRepo = matchRepo;
 exports.hashToken = hashToken;
 exports.claudeCodeInstalled = claudeCodeInstalled;
 exports.codexInstalled = codexInstalled;
+exports.cursorInstalled = cursorInstalled;
 exports.installHook = installHook;
 exports.installClaudeCodeInstructions = installClaudeCodeInstructions;
 exports.installCodexInstructions = installCodexInstructions;
+exports.installCursorInstructions = installCursorInstructions;
 exports.installClaudeCodeMcp = installClaudeCodeMcp;
+exports.installCursorMcp = installCursorMcp;
 exports.installCodexMcp = installCodexMcp;
 exports.installCodexHook = installCodexHook;
+exports.installCursorHook = installCursorHook;
 exports.parseClaudeCodeStats = parseClaudeCodeStats;
 exports.parseCodexStats = parseCodexStats;
 exports.extractCodexRepoUrl = extractCodexRepoUrl;
@@ -133,12 +137,20 @@ const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json")
 const CLAUDE_DIR = path.join(os.homedir(), ".claude");
 const CODEX_HOOKS_PATH = path.join(os.homedir(), ".codex", "hooks.json");
 const CODEX_DIR = path.join(os.homedir(), ".codex");
+const CURSOR_DIR = path.join(os.homedir(), ".cursor");
+const CURSOR_HOOKS_PATH = path.join(CURSOR_DIR, "hooks.json");
+const CURSOR_MCP_PATH = path.join(CURSOR_DIR, "mcp.json");
+const CURSOR_RULES_DIR = path.join(CURSOR_DIR, "rules");
+const CURSOR_RULES_PATH = path.join(CURSOR_RULES_DIR, "codiedev.mdc");
 function claudeCodeInstalled() {
     return fs.existsSync(CLAUDE_DIR);
 }
 function codexInstalled() {
     return fs.existsSync(CODEX_DIR);
 }
+function cursorInstalled() {
+    return fs.existsSync(CURSOR_DIR);
+}
 function installHook() {
     let settings = {};
     try {
@@ -218,6 +230,7 @@ thought, use the \`codiedev\` CLI via Bash:**
 | "share with Greg" / "give Jason access" (no notification) | MCP tool \`codiedev_share_with\` |
 | "send this to Greg" / "ask Greg to look at this" | MCP tool \`codiedev_send_to\` |
 | "find something about X" / "has anyone solved Y?" | MCP tool \`codiedev_search\` |
+| "why did we…?" / "what does the team know about X?" | MCP tool \`codiedev_ask\` (synthesized answer + citations) |
 | "show my library" / "what artifacts exist?" | MCP tool \`codiedev_get_library\` |
 | "react 🛠 to that post" / "mark as used" | MCP tool \`codiedev_react\` |
 
@@ -311,25 +324,74 @@ function installClaudeCodeInstructions() {
 function installCodexInstructions() {
     writeInstructionsBlock(CODEX_USER_INSTRUCTIONS_PATH);
 }
+// Cursor uses .mdc rule files with YAML frontmatter (description, alwaysApply,
+// globs). `.cursorrules` is deprecated and ignored by Agent mode as of 2026.
+const CURSOR_INSTRUCTIONS_FRONTMATTER = `---
+description: CodieDev team artifact layer — push, pull, search, ping, and share artifacts with teammates
+alwaysApply: true
+---
+
+`;
+function installCursorInstructions() {
+    if (!fs.existsSync(CURSOR_RULES_DIR)) {
+        fs.mkdirSync(CURSOR_RULES_DIR, { recursive: true });
+    }
+    const block = CURSOR_INSTRUCTIONS_FRONTMATTER +
+        CODIEDEV_INSTRUCTIONS_BEGIN +
+        "\n" +
+        CODIEDEV_INSTRUCTIONS_BODY +
+        "\n" +
+        CODIEDEV_INSTRUCTIONS_END +
+        "\n";
+    let existing = "";
+    if (fs.existsSync(CURSOR_RULES_PATH)) {
+        existing = fs.readFileSync(CURSOR_RULES_PATH, "utf8");
+    }
+    // If the file already has our markers, replace just the block — preserve
+    // any frontmatter edits the user made.
+    const beginIdx = existing.indexOf(CODIEDEV_INSTRUCTIONS_BEGIN);
+    const endIdx = existing.indexOf(CODIEDEV_INSTRUCTIONS_END);
+    let next;
+    if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
+        next =
+            existing.slice(0, beginIdx) +
+                CODIEDEV_INSTRUCTIONS_BEGIN +
+                "\n" +
+                CODIEDEV_INSTRUCTIONS_BODY +
+                "\n" +
+                CODIEDEV_INSTRUCTIONS_END +
+                existing.slice(endIdx + CODIEDEV_INSTRUCTIONS_END.length);
+    }
+    else {
+        next = block;
+    }
+    fs.writeFileSync(CURSOR_RULES_PATH, next, "utf8");
+}
+function readMcpConfigSafely(path) {
+    if (!fs.existsSync(path))
+        return {};
+    const raw = fs.readFileSync(path, "utf8");
+    if (!raw.trim())
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        const backup = `${path}.bak.${Date.now()}`;
+        fs.copyFileSync(path, backup);
+        console.warn(`Warning: ${path} contained invalid JSON. Backed up to ${backup} before rewriting.`);
+        return {};
+    }
+}
 /**
  * Install the CodieDev MCP server into Claude Code's user-scope config.
  * Safe to call multiple times — updates the existing entry if present.
  */
 function installClaudeCodeMcp() {
-    let config = {};
-    try {
-        if (fs.existsSync(CLAUDE_USER_CONFIG_PATH)) {
-            const raw = fs.readFileSync(CLAUDE_USER_CONFIG_PATH, "utf8");
-            config = raw.trim() ? JSON.parse(raw) : {};
-        }
-    }
-    catch {
-        // Start fresh if the existing file is corrupt — safer than failing the install.
-        config = {};
-    }
+    const config = readMcpConfigSafely(CLAUDE_USER_CONFIG_PATH);
     const mcpServers = config.mcpServers ?? {};
-    // Canonical Claude Code user-scope format: just command + args.
-    // No `type` field (some CC versions reject it; stdio is the default).
+    if (mcpServers.codiedev)
+        return;
     mcpServers.codiedev = {
         command: "npx",
         args: ["codiedev-mcp"],
@@ -337,6 +399,27 @@ function installClaudeCodeMcp() {
     config.mcpServers = mcpServers;
     fs.writeFileSync(CLAUDE_USER_CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
 }
+/**
+ * Install the CodieDev MCP server into Cursor's user-scope config.
+ * Cursor uses the same `mcpServers` schema as Claude Code; just a different
+ * file path (~/.cursor/mcp.json). Project-scoped servers can also live at
+ * <project>/.cursor/mcp.json — we only manage the user-scope one.
+ */
+function installCursorMcp() {
+    if (!fs.existsSync(CURSOR_DIR)) {
+        fs.mkdirSync(CURSOR_DIR, { recursive: true });
+    }
+    const config = readMcpConfigSafely(CURSOR_MCP_PATH);
+    const mcpServers = config.mcpServers ?? {};
+    if (mcpServers.codiedev)
+        return;
+    mcpServers.codiedev = {
+        command: "npx",
+        args: ["codiedev-mcp"],
+    };
+    config.mcpServers = mcpServers;
+    fs.writeFileSync(CURSOR_MCP_PATH, JSON.stringify(config, null, 2), "utf8");
+}
 /**
  * Best-effort append of the CodieDev MCP server block to ~/.codex/config.toml.
  *
@@ -413,6 +496,49 @@ function installCodexHook() {
     }
     fs.writeFileSync(CODEX_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
 }
+// Cursor's hooks.json uses { version: 1, hooks: { sessionEnd: [{ command, type, timeout }] } }.
+// `sessionEnd` fires when a conversation closes (completed, aborted, error,
+// window_close, user_close); the base stdin payload includes transcript_path
+// and session_id which `codiedev-hook capture-cursor` reads to upload.
+function installCursorHook() {
+    if (!fs.existsSync(CURSOR_DIR)) {
+        fs.mkdirSync(CURSOR_DIR, { recursive: true });
+    }
+    let hooksFile = {};
+    try {
+        if (fs.existsSync(CURSOR_HOOKS_PATH)) {
+            const raw = fs.readFileSync(CURSOR_HOOKS_PATH, "utf8");
+            hooksFile = raw.trim() ? JSON.parse(raw) : {};
+        }
+    }
+    catch {
+        hooksFile = {};
+    }
+    if (!hooksFile.version) {
+        hooksFile.version = 1;
+    }
+    if (!hooksFile.hooks) {
+        hooksFile.hooks = {};
+    }
+    const hooks = hooksFile.hooks;
+    if (!hooks.sessionEnd) {
+        hooks.sessionEnd = [];
+    }
+    const sessionEndHooks = hooks.sessionEnd;
+    const alreadyInstalled = sessionEndHooks.some((h) => {
+        const cmd = h.command;
+        return cmd && cmd.includes("codiedev-hook");
+    });
+    if (alreadyInstalled) {
+        return;
+    }
+    sessionEndHooks.push({
+        command: "npx codiedev-hook capture-cursor",
+        type: "command",
+        timeout: 30,
+    });
+    fs.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
+}
 function parseClaudeCodeStats(content) {
     let messageCount = 0;
     let toolCallCount = 0;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codiedev",
-  "version": "0.5.5",
-  "description": "Connect Claude Code or Codex to CodieDev for org-wide session capture and artifact collaboration",
+  "version": "0.6.0",
+  "description": "Connect Claude Code, Codex, or Cursor to CodieDev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "./dist/cli.js",
     "codiedev-hook": "./dist/hook.js"
@@ -21,6 +21,7 @@
     "claude",
     "codex",
     "openai",
+    "cursor",
     "ai",
     "session-capture"
   ],