codiedev 0.9.51 → 0.10.0-beta.1

package/README.md

@@ -12,7 +12,7 @@ The CLI will prompt you for an API token (get one at https://codiedev.com/portal
 
 - **Claude Code** — `SessionEnd` hook in `~/.claude/settings.json`
 - **Codex** — `Stop` hook in `~/.codex/hooks.json`
-- **Cursor** — `sessionEnd` hook in `~/.cursor/hooks.json`
+- **Cursor** — native session, prompt-security, tool-security, backup, and capture hooks in `~/.cursor/hooks.json`
 - **OpenCode / Codie** — plugin in `~/.config/opencode/plugins/codiedev.js`
 
 Installed clients are wired automatically. The OpenCode adapter is staged even
@@ -49,6 +49,14 @@ container needs its own rule unless `~/.codiedev/config.json` is persisted.
 
 Codex doesn't currently expose a `SessionEnd` event, so the hook runs on `Stop` (fires after each assistant turn). The backend dedupes by `(company, session_id)` and replaces the stored transcript on re-upload so the latest turn's snapshot wins. Summarization happens once per session; subsequent turn uploads keep the raw transcript fresh but don't re-summarize (to avoid running up LLM cost).
 
+## Cursor note
+
+Cursor uses its native hook events for session start/end, prompt blocking,
+pre/post-tool security, and stop-time backup. Cursor's `beforeSubmitPrompt`
+cannot inject dynamic context today, so task-specific discovery is not claimed.
+Cursor sessions keep their source
+label and real transcript statistics through the shared capture pipeline.
+
 ## OpenCode note
 
 OpenCode exposes session lifecycle events through plugins. Codiedev snapshots

package/dist/cli.js

@@ -29,7 +29,6 @@ const createTicket_1 = require("./commands/createTicket");
 const doctor_1 = require("./commands/doctor");
 const search_1 = require("./commands/search");
 const library_1 = require("./commands/library");
-const post_1 = require("./commands/post");
 const share_1 = require("./commands/share");
 const send_1 = require("./commands/send");
 const react_1 = require("./commands/react");
@@ -44,7 +43,7 @@ Codiedev CLI
   someone left off across sessions and providers.
 
 Connect:
-  codiedev connect                       Link Claude Code / Codex to your org
+  codiedev connect                       Link Claude Code / Codex / Cursor to your org
   codiedev doctor                        Verify setup, capture, and Agent Security
   codiedev security pilot                Run safe synthetic policy checks
   codiedev security inventory            Inventory MCPs, skills, hooks, plugins,
@@ -105,9 +104,6 @@ Discovery:
                                          List artifacts in your workspace
 
 Feed:
-  codiedev post --title "<t>" --body "<b>" [--intent share|request_review|
-                request_expertise|link_share|rfc] [--filename <key>]
-                [--mention <name>]...    Publish to the team feed
   codiedev react <postId> <emoji>        Toggle a reaction on a feed post
 
 Privacy:
@@ -135,7 +131,7 @@ Other artifact types (rare — use the matching prefix):
 
 Skills (slash commands):
   Add 'name:' + 'description:' YAML frontmatter to any pushed file
-  and it shows up as /<name> in Claude Code / Codex. Filename
+  and it shows up as /<name> in Claude Code / Codex / Cursor. Filename
   prefix doesn't matter — frontmatter is the signal.
 
 Examples:
@@ -172,6 +168,8 @@ codiedev connect — link your agent CLI to Codiedev
     - ~/.claude/CLAUDE.md instructions   (teaches Claude the commands)
     - ~/.codex/hooks.json hook           (same, for Codex)
     - ~/.codex/AGENTS.md instructions    (same, for Codex)
+    - ~/.cursor/hooks.json hooks         (session, prompt, security, capture)
+    - ~/.cursor/rules/codiedev.mdc       (teaches Cursor the commands)
 
   Re-run anytime to swap accounts or refresh the instruction block.
 
@@ -374,7 +372,7 @@ Default path:
          # body...
     3. codiedev push portal-design.md
 
-It's now /portal-design in Claude Code / Codex.
+It's now /portal-design in Claude Code / Codex / Cursor.
 
 Filename prefix is irrelevant for skills — frontmatter is the only
 signal. The stored artifact type still follows the filename rule
@@ -392,7 +390,7 @@ email notifications when pinged.
 
 ## Agent-native
 
-If you use Claude Code or Codex, the agent already knows the commands —
+If you use Claude Code, Codex, or Cursor, the agent already knows the commands —
 'codiedev connect' installs instructions into your user-level config.
 Just say things like:
 
@@ -513,9 +511,6 @@ async function main() {
             case "ls":
                 await (0, library_1.runLibrary)(rest);
                 return;
-            case "post":
-                await (0, post_1.runPost)(rest);
-                return;
             case "share":
                 await (0, share_1.runShare)(rest);
                 return;

package/dist/codieStartup.d.ts

@@ -4,6 +4,7 @@ export interface CodieStartupConfig extends AgentSecurityEntitlement {
     backendUrl?: string;
     token?: string;
     companyId?: string;
+    deviceId?: string;
 }
 export type CodiePolicyRefreshResult = {
     status: "disabled";
@@ -21,4 +22,5 @@ export declare function refreshCodieSecurityPolicy(config: CodieStartupConfig, s
     backendUrl: string;
     token: string;
     companyId: string;
+    deviceId?: string;
 }, source?: AgentSurface) => Promise<EndpointSecurityPolicy>): Promise<CodiePolicyRefreshResult>;

package/dist/codieStartup.js

@@ -17,6 +17,7 @@ async function refreshCodieSecurityPolicy(config, syncPolicy = securityPolicy_1.
             backendUrl: config.backendUrl,
             token: config.token,
             companyId: config.companyId,
+            ...(config.deviceId ? { deviceId: config.deviceId } : {}),
         }, "codie-harness");
         return { status: "synced", policy };
     }

package/dist/connect.js

@@ -291,6 +291,7 @@ async function runConnect(args = []) {
     const securityConfigPaths = [
         path.join(home, ".claude", "settings.json"),
         path.join(home, ".codex", "hooks.json"),
+        path.join(home, ".cursor", "hooks.json"),
         path.join(home, ".config", "opencode", "plugins", "codiedev.js"),
         path.join(home, ".codex", "config.toml"),
     ];
@@ -327,7 +328,7 @@ async function runConnect(args = []) {
         runInstall("codex-instructions", utils_1.installCodexInstructions, "Codex agent instructions (~/.codex/AGENTS.md)", "codex-instructions");
     }
     if (hasCursor) {
-        runInstall("cursor-hook", utils_1.installCursorHook, "Cursor sessionEnd (capture + auto-backup) hooks (~/.cursor/hooks.json)", "cursor-hook");
+        runInstall("cursor-hook", () => (0, utils_1.installCursorHook)(agentSecurityEnabled), "Cursor sessionStart + prompt security + stop backup + sessionEnd capture hooks (~/.cursor/hooks.json)", "cursor-hook");
         runInstall("cursor-instructions", utils_1.installCursorInstructions, "Cursor agent instructions (~/.cursor/rules/codiedev.mdc)", "cursor-instructions");
     }
     // Always stage the adapter. It is dormant until OpenCode starts, which lets
@@ -345,8 +346,10 @@ async function runConnect(args = []) {
                 targets.push({ surface: "claude-code", configPath: securityConfigPaths[0] });
             if (installedTargets.includes("codex-hook"))
                 targets.push({ surface: "codex", configPath: securityConfigPaths[1] });
+            if (installedTargets.includes("cursor-hook"))
+                targets.push({ surface: "cursor", configPath: securityConfigPaths[2] });
             if (installedTargets.includes("opencode-capture"))
-                targets.push({ surface: "codie-harness", configPath: securityConfigPaths[2] });
+                targets.push({ surface: "codie-harness", configPath: securityConfigPaths[3] });
             (0, securityInstall_1.writeSecurityInstallManifest)({ hookScriptPath, snapshot: securitySnapshot, targets });
         }
     }

package/dist/cursorHooks.d.ts

@@ -0,0 +1,23 @@
+/** Cursor's native hook payload is close to Claude Code's, but its stable
+ * conversation identifier and several tool fields use different names. Keep
+ * the translation at the process boundary so the shared capture/security
+ * pipeline never has to guess which surface produced an event. */
+export declare function normalizeCursorHookInput<T extends Record<string, unknown>>(input: T): T & Record<string, unknown>;
+/** Cursor stores JSONL message roles in `role`; the shared capture pipeline
+ * uses Claude's top-level `type` discriminator. Preserve all original fields
+ * and add only that discriminator so the existing parsers see real messages. */
+export declare function normalizeCursorTranscript(content: string): string;
+/** Cursor may change its private JSONL record shape independently of the hook
+ * contract. Only a byte-empty snapshot is safe to discard; a non-empty file
+ * that the current normalizer cannot parse must still be uploaded for backend
+ * recovery and diagnosis. */
+export declare function isCursorTranscriptEmpty(content: string): boolean;
+export declare function cursorPreToolBlockResponse(reason: string): {
+    permission: "deny";
+    user_message: string;
+    agent_message: string;
+};
+export declare function cursorPromptBlockResponse(reason: string): {
+    continue: false;
+    user_message: string;
+};

package/dist/cursorHooks.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCursorHookInput = normalizeCursorHookInput;
+exports.normalizeCursorTranscript = normalizeCursorTranscript;
+exports.isCursorTranscriptEmpty = isCursorTranscriptEmpty;
+exports.cursorPreToolBlockResponse = cursorPreToolBlockResponse;
+exports.cursorPromptBlockResponse = cursorPromptBlockResponse;
+/** Cursor's native hook payload is close to Claude Code's, but its stable
+ * conversation identifier and several tool fields use different names. Keep
+ * the translation at the process boundary so the shared capture/security
+ * pipeline never has to guess which surface produced an event. */
+function normalizeCursorHookInput(input) {
+    const sessionId = firstString(input.session_id, input.sessionId, input.conversation_id);
+    const roots = Array.isArray(input.workspace_roots)
+        ? input.workspace_roots.filter((root) => typeof root === "string")
+        : [];
+    const cwd = firstString(input.cwd, roots[0]);
+    const duration = firstNumber(input.duration_ms, input.durationMs, input.duration);
+    return {
+        ...input,
+        ...(sessionId ? { session_id: sessionId } : {}),
+        ...(cwd ? { cwd } : {}),
+        ...(input.tool_response === undefined && input.toolResponse === undefined && input.tool_output !== undefined
+            ? { tool_response: input.tool_output }
+            : {}),
+        ...(input.error === undefined && input.error_message !== undefined
+            ? { error: input.error_message }
+            : {}),
+        ...(duration !== undefined ? { duration_ms: duration } : {}),
+    };
+}
+/** Cursor stores JSONL message roles in `role`; the shared capture pipeline
+ * uses Claude's top-level `type` discriminator. Preserve all original fields
+ * and add only that discriminator so the existing parsers see real messages. */
+function normalizeCursorTranscript(content) {
+    return content
+        .split("\n")
+        .map((line) => {
+        if (!line.trim())
+            return line;
+        try {
+            const entry = JSON.parse(line);
+            if ((entry.role === "user" || entry.role === "assistant") &&
+                entry.type === undefined) {
+                return JSON.stringify({ ...entry, type: entry.role });
+            }
+        }
+        catch {
+            // Preserve malformed/non-JSON lines; tolerant downstream parsers skip
+            // anything they cannot consume.
+        }
+        return line;
+    })
+        .join("\n");
+}
+/** Cursor may change its private JSONL record shape independently of the hook
+ * contract. Only a byte-empty snapshot is safe to discard; a non-empty file
+ * that the current normalizer cannot parse must still be uploaded for backend
+ * recovery and diagnosis. */
+function isCursorTranscriptEmpty(content) {
+    return content.trim().length === 0;
+}
+function firstString(...values) {
+    return values.find((value) => typeof value === "string" && value.trim().length > 0);
+}
+function firstNumber(...values) {
+    return values.find((value) => typeof value === "number" && Number.isFinite(value));
+}
+function cursorPreToolBlockResponse(reason) {
+    return {
+        permission: "deny",
+        user_message: reason,
+        agent_message: reason,
+    };
+}
+function cursorPromptBlockResponse(reason) {
+    return {
+        continue: false,
+        user_message: reason,
+    };
+}

package/dist/hook.js

@@ -37,12 +37,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildDiscoveryContext = buildDiscoveryContext;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
-const path = __importStar(require("path"));
 const https = __importStar(require("https"));
 const http = __importStar(require("http"));
 const child_process_1 = require("child_process");
 const utils_1 = require("./utils");
-const limitEvent_1 = require("./limitEvent");
+const limitEventReporter_1 = require("./limitEventReporter");
 const version_1 = require("./version");
 const captureLog_1 = require("./captureLog");
 const security_1 = require("./security");
@@ -51,6 +50,7 @@ const securityPolicy_1 = require("./securityPolicy");
 const securityFeature_1 = require("./securityFeature");
 const securityInventory_1 = require("./securityInventory");
 const captureExclusions_1 = require("./captureExclusions");
+const cursorHooks_1 = require("./cursorHooks");
 // Pure builder for the discovery additionalContext. Returns null when there are
 // no matches. The suggested `codiedev pull` command carries the EXACT top key
 // (e.g. "pr-push.md") rather than a "<key>" placeholder — otherwise agents
@@ -98,43 +98,58 @@ async function runDiscover(prompt) {
     }
     process.exit(0);
 }
+function readTranscriptTailFile(transcriptPath, maxBytes = 512 * 1024) {
+    const size = fs.statSync(transcriptPath).size;
+    if (size <= maxBytes)
+        return fs.readFileSync(transcriptPath, "utf8");
+    const handle = fs.openSync(transcriptPath, "r");
+    try {
+        const buffer = Buffer.allocUnsafe(maxBytes);
+        const bytesRead = fs.readSync(handle, buffer, 0, maxBytes, size - maxBytes);
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        fs.closeSync(handle);
+    }
+}
 // StopFailure (matcher rate_limit): the dev just got blocked. Read the local
 // transcript tail for the ground-truth rate_limit line and POST a tiny event.
 // Best-effort + silent — StopFailure output is ignored by Claude Code anyway.
-async function runStopFailure(hookInput) {
+async function readAndPostLimitEvent(hookInput, source, emitMinimalOnMiss) {
     const config = (0, utils_1.readConfig)();
     if (!config)
         process.exit(0);
-    let event = null;
-    let transcriptTail;
+    let transcript = "";
     const tp = hookInput.transcript_path;
     if (tp) {
         try {
-            const transcript = fs.readFileSync(tp, "utf8");
-            event = (0, limitEvent_1.parseLimitEventFromTranscript)(transcript);
-            // Ship the tail with the event so the server can summarize "what they
-            // were working on" right now — no waiting for the SessionEnd capture.
-            transcriptTail = (0, limitEvent_1.tailForLimitEvent)(transcript) || undefined;
+            // Codex invokes Stop after every turn. Bound this read so long-running
+            // sessions do not repeatedly load their entire rollout into memory.
+            transcript = readTranscriptTailFile(tp);
         }
         catch {
             /* unreadable transcript — fall through to minimal event */
         }
     }
-    // The hook is registered with matcher "rate_limit", so a miss still means a
-    // real limit — emit a minimal event rather than dropping it.
-    const payload = event ?? { kind: "other", at: Date.now(), resetText: null };
     try {
-        await postJson(`${config.backendUrl}/api/cli/limitEvent`, {
-            kind: payload.kind,
-            at: payload.at,
-            resetText: payload.resetText,
+        await (0, limitEventReporter_1.reportTranscriptLimitEvent)({
+            config,
+            source,
             sessionId: hookInput.session_id,
-            transcriptTail,
-        }, config.token);
+            transcript,
+            emitMinimalOnMiss,
+        });
     }
     catch {
         /* best-effort */
     }
+}
+async function runStopFailure(hookInput) {
+    await readAndPostLimitEvent(hookInput, "claude-code", true);
+    process.exit(0);
+}
+async function runCodexLimit(hookInput) {
+    await readAndPostLimitEvent(hookInput, "codex", false);
     process.exit(0);
 }
 // Skip-reason ping: this session is ending WITHOUT a capture, and here's why.
@@ -294,13 +309,16 @@ async function runSecurityHook(hookInput, phase, source, uploadTelemetry = true)
         });
         if (uploadTelemetry)
             dispatchSecurityEventUpload(event);
-        process.stdout.write(JSON.stringify({
-            hookSpecificOutput: {
-                hookEventName: "PreToolUse",
-                permissionDecision: "deny",
-                permissionDecisionReason: localDecision.reason,
-            },
-        }));
+        const response = source === "cursor"
+            ? (0, cursorHooks_1.cursorPreToolBlockResponse)(localDecision.reason ?? "Codie blocked this action")
+            : {
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "deny",
+                    permissionDecisionReason: localDecision.reason,
+                },
+            };
+        process.stdout.write(JSON.stringify(response));
         return;
     }
     if (!event)
@@ -324,10 +342,10 @@ function runPromptSecurityHook(hookInput, source, uploadTelemetry = true) {
     if (uploadTelemetry) {
         dispatchSecurityEventUpload((0, security_1.buildBlockedSecurityPromptEvent)(hookInput, source, decision.category ?? "secret_in_prompt"));
     }
-    process.stdout.write(JSON.stringify({
-        decision: "block",
-        reason: decision.reason,
-    }));
+    const response = source === "cursor"
+        ? (0, cursorHooks_1.cursorPromptBlockResponse)(decision.reason ?? "Codie blocked this prompt")
+        : { decision: "block", reason: decision.reason };
+    process.stdout.write(JSON.stringify(response));
     return true;
 }
 function dispatchAllowedPromptSecurityEvent(hookInput, source) {
@@ -361,10 +379,13 @@ async function runSecurityEventUpload() {
     try {
         const raw = await readStdin();
         const event = JSON.parse(raw);
+        const cachedPolicy = (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId);
         const eventWithEndpoint = (0, security_1.withEndpointIdentity)(event, {
             endpointId: config.deviceId,
             endpointName: config.deviceName,
             cliVersion: version_1.CLI_VERSION,
+            securityRuntimeVersion: security_1.SECURITY_RUNTIME_VERSION,
+            securityPolicyVersion: cachedPolicy?.policyVersion,
         });
         const result = await postJsonForResponse(`${config.backendUrl}/api/cli/securityEvent`, { ...eventWithEndpoint }, config.token, 
         // Leave room for a cold backend and durable scheduling. This uploader is
@@ -445,7 +466,7 @@ async function readStdin() {
 function resolveMode(arg) {
     if (arg === "capture-codex")
         return "codex";
-    if (arg === "capture-cursor")
+    if (arg === "capture-cursor" || arg === "backup-cursor")
         return "cursor";
     if (arg === "capture-opencode" || arg === "capture-opencode-final")
         return "opencode";
@@ -574,7 +595,10 @@ async function main() {
     try {
         const raw = await readStdin();
         if (raw.trim()) {
-            hookInput = JSON.parse(raw);
+            const parsed = JSON.parse(raw);
+            hookInput = (process.argv[2]?.endsWith("-cursor")
+                ? (0, cursorHooks_1.normalizeCursorHookInput)(parsed)
+                : parsed);
         }
     }
     catch {
@@ -585,18 +609,28 @@ async function main() {
     // disabled; all other hook modes still exit before making a network request.
     const captureIgnored = (0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput);
     const securityCommand = process.argv[2] ?? "";
-    const securityMatch = securityCommand.match(/^security-(pre|post|failure)(?:-(codex|codie))?$/);
+    const securityMatch = securityCommand.match(/^security-(pre|post|failure)(?:-(codex|cursor|codie))?$/);
     if (securityMatch) {
         const source = securityMatch[2] === "codex"
             ? "codex"
-            : securityMatch[2] === "codie"
-                ? "codie-harness"
-                : "claude-code";
+            : securityMatch[2] === "cursor"
+                ? "cursor"
+                : securityMatch[2] === "codie"
+                    ? "codie-harness"
+                    : "claude-code";
         await runSecurityHook(hookInput, securityMatch[1], source, !captureIgnored);
         process.exit(0);
     }
     // UserPromptSubmit discovery path — separate from session capture.
     const promptCommand = process.argv[2] ?? "";
+    if (promptCommand === "security-prompt-cursor") {
+        if (runPromptSecurityHook(hookInput, "cursor", !captureIgnored))
+            return;
+        if (captureIgnored)
+            return;
+        dispatchAllowedPromptSecurityEvent(hookInput, "cursor");
+        process.exit(0);
+    }
     if (process.argv[2] === "discover" ||
         process.argv[2] === "discover-codex" ||
         process.argv[2] === "discover-codie") {
@@ -622,8 +656,14 @@ async function main() {
         await runStopFailure(hookInput);
         return;
     }
+    if (process.argv[2] === "limit-codex") {
+        await runCodexLimit(hookInput);
+        return;
+    }
     // SessionStart: post the capture-coverage denominator ping. Tiny + fast.
-    if (process.argv[2] === "session-start" || process.argv[2] === "session-start-opencode") {
+    if (process.argv[2] === "session-start" ||
+        process.argv[2] === "session-start-cursor" ||
+        process.argv[2] === "session-start-opencode") {
         if ((0, securityFeature_1.isAgentSecurityEnabled)((0, utils_1.readConfig)()) && (0, securityInventory_1.securityInventoryDue)()) {
             try {
                 const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1], "security-inventory-upload", hookInput.cwd || process.cwd()], {
@@ -634,7 +674,11 @@ async function main() {
             }
             catch { /* daily inventory is best-effort */ }
         }
-        await runSessionStart(hookInput, process.argv[2] === "session-start-opencode" ? "opencode" : "claude-code");
+        await runSessionStart(hookInput, process.argv[2] === "session-start-opencode"
+            ? "opencode"
+            : process.argv[2] === "session-start-cursor"
+                ? "cursor"
+                : "claude-code");
         return;
     }
     // Self-heal: a user who upgraded the CLI but hasn't re-run `connect` gets
@@ -642,7 +686,14 @@ async function main() {
     // no self-heal and could stay stripped forever while SessionStart kept
     // pinging (the Sonifi "starts arrive, captures never" loss) — re-wired on
     // their next Stop/SessionEnd. One read + one write, only when missing.
-    (0, utils_1.ensureAllCodiedevHooksInstalled)();
+    if ((process.argv[2] ?? "").endsWith("-cursor")) {
+        (0, utils_1.ensureCursorCodiedevHooksInstalled)();
+    }
+    else {
+        (0, utils_1.ensureAllCodiedevHooksInstalled)();
+    }
+    if (process.argv[2] === "capture-codex")
+        (0, utils_1.ensureCodexLimitHookInstalled)();
     const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]
@@ -655,13 +706,11 @@ async function main() {
     // extension) where SessionEnd may never come — the silent zero-capture bug.
     // Same detached capture-finish child as SessionEnd, marked non-final so the
     // server renews the session lease instead of summarizing immediately.
-    if (process.argv[2] === "backup") {
+    if (process.argv[2] === "backup" || process.argv[2] === "backup-cursor") {
         if (transcript_path) {
             try {
                 (0, utils_1.dispatchCaptureFinish)({
-                    // "capture" = the claude-code entrypoint literal, same as the
-                    // SessionEnd path below (resolveMode maps it to claude-code).
-                    mode: "capture",
+                    mode: process.argv[2] === "backup-cursor" ? "capture-cursor" : "capture",
                     session_id,
                     transcript_path,
                     cwd,
@@ -721,10 +770,9 @@ async function main() {
             transcript_path,
             cwd,
             workspace_roots,
-            // final:true ONLY for claude-code's SessionEnd. Codex routes its
-            // per-turn Stop hook through "capture-codex" — final:true there would
-            // close the server lease every turn. Codex/Cursor keep legacy
-            // behaviour (final omitted).
+            // final:true for real SessionEnd signals (Claude Code and Cursor).
+            // Codex routes its per-turn Stop hook through "capture-codex" —
+            // final:true there would close the server lease every turn.
             final: (0, utils_1.resolveCaptureFinal)(process.argv[2]),
         }, process.argv[1], { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile: jobFile, openSync: fs.openSync, closeSync: fs.closeSync });
     }
@@ -801,7 +849,9 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
             outcome: "skip",
             detail: reason,
         });
-        await postSessionSkip(config, session_id, reason);
+        if ((0, utils_1.shouldReportCaptureSkip)(input.final)) {
+            await postSessionSkip(config, session_id, reason);
+        }
         return;
     }
     // Snapshot the RAW transcript before normalization below flattens it to
@@ -813,6 +863,9 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     if (parserMode === "opencode") {
         transcriptContent = (0, utils_1.normalizeOpenCodeTranscript)(transcriptContent);
     }
+    else if (parserMode === "cursor") {
+        transcriptContent = (0, cursorHooks_1.normalizeCursorTranscript)(transcriptContent);
+    }
     // Resolve repo URL. Codex embeds it in session_meta; CC and Cursor both
     // need the git remote of the workspace.
     let remoteUrl = null;
@@ -839,9 +892,26 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     const matchedRepo = remoteUrl ? (0, utils_1.matchRepo)(remoteUrl, config.repos) : null;
     const stats = parserMode === "codex"
         ? (0, utils_1.parseCodexStats)(transcriptContent)
-        : parserMode === "cursor"
-            ? { messageCount: 0, toolCallCount: 0 }
-            : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
+        : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
+    // Cursor can emit duplicate lifecycle notifications while one transcript
+    // path is still byte-empty. Never use parsed message count here: Cursor's
+    // private JSONL shape can evolve independently, and parser drift must not
+    // silently discard a real non-empty session.
+    if (parserMode === "cursor" && (0, cursorHooks_1.isCursorTranscriptEmpty)(rawTranscriptContent)) {
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "capture-finish",
+            sessionId: session_id,
+            outcome: "skip",
+            detail: "empty-cursor-transcript",
+        });
+        // A non-final stop snapshot is only a backup; reporting it as a skipped
+        // session would close/remove server-side start coverage while the session
+        // is still alive. The real SessionEnd remains responsible for a skip ping.
+        if ((0, utils_1.shouldReportCaptureSkip)(input.final)) {
+            await postSessionSkip(config, session_id, "empty-cursor-transcript");
+        }
+        return;
+    }
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
     // Session→merge join keys: the branch + HEAD sha the work happened on. Matched
     // server-side against a merged MR/PR's source_branch / commits for AI attribution.
@@ -934,7 +1004,7 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     // which is the "supersede" mechanism for the deferred path.
     try {
         const hookScriptPath = process.argv[1];
-        const tmpFile = path.join(os.tmpdir(), `codiedev-capture-${session_id ?? process.pid}.json`);
+        const tmpFile = (0, utils_1.captureUploadTmpFile)(session_id, decision.mode);
         if (decision.mode === "immediate") {
             (0, utils_1.dispatchCaptureDetached)({
                 url: `${config.backendUrl}/api/captureSession`,
@@ -942,6 +1012,11 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
                 body: payload,
                 scopePaths,
             }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync });
+            // The immediate payload is durable before removing the older scheduled
+            // snapshot. Do this for every immediate dispatch, not only SessionEnd:
+            // first/outside-window snapshots also supersede a sleeping deferred job.
+            if (session_id)
+                (0, utils_1.cancelDeferredCaptureUpload)(session_id);
             // Retry any earlier capture jobs that failed to upload (transient network
             // blips), excluding the one we just dispatched. Best-effort, detached.
             // Skip the sweep on deferred path — the deferred child will handle uploading.

package/dist/limitEvent.d.ts

@@ -1,9 +1,16 @@
-export type LimitKind = "session" | "org_spend" | "other";
+export type LimitKind = "session" | "user_spend" | "org_spend" | "other";
 export interface LimitEvent {
     kind: LimitKind;
     at: number;
     resetText: string | null;
+    reason?: string;
 }
 export declare function classifyLimitKind(text: string): LimitKind;
 export declare function parseLimitEventFromTranscript(transcript: string): LimitEvent | null;
+/**
+ * Codex writes a structured RateLimitSnapshot on token_count events. A normal
+ * turn has `rate_limit_reached_type: null`; a blocked turn names the exact
+ * boundary. Reading that field avoids locale-dependent terminal copy.
+ */
+export declare function parseCodexLimitEventFromTranscript(transcript: string): LimitEvent | null;
 export declare function tailForLimitEvent(transcript: string, maxChars?: number): string;