codiedev 0.9.51 → 0.9.53

package/dist/cursorHooks.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCursorHookInput = normalizeCursorHookInput;
+exports.normalizeCursorTranscript = normalizeCursorTranscript;
+exports.isCursorTranscriptEmpty = isCursorTranscriptEmpty;
+/** Normalize Cursor's native hook payload into the shared capture shape. */
+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 } : {}),
+    };
+}
+/** Add Claude-compatible message discriminators while preserving Cursor JSONL. */
+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 {
+            // Tolerant downstream parsers skip malformed/non-JSON lines.
+        }
+        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));
+}

package/dist/hook.js

@@ -37,20 +37,15 @@ 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");
-const securitySession_1 = require("./securitySession");
-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 +93,56 @@ 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;
+            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.
@@ -223,7 +231,7 @@ timeoutMs) {
 // postJson variant that returns the parsed response body — the upload-URL
 // handshake needs the { uploadUrl } the server hands back. No timeout: runs
 // only in detached uploader children, never on the shutdown clock.
-function postJsonForResponse(url, body, bearerToken, timeoutMs) {
+function postJsonForResponse(url, body, bearerToken) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
         const data = JSON.stringify(body);
@@ -257,139 +265,10 @@ function postJsonForResponse(url, body, bearerToken, timeoutMs) {
             });
         });
         req.on("error", reject);
-        if (timeoutMs) {
-            req.setTimeout(timeoutMs, () => {
-                req.destroy(new Error(`timeout after ${timeoutMs}ms`));
-            });
-        }
         req.write(data);
         req.end();
     });
 }
-// Local policy runs synchronously before a tool executes. Workflow telemetry
-// is dispatched separately and fail-open, so a detector outage or timeout can
-// never delay or override the deterministic endpoint decision.
-async function runSecurityHook(hookInput, phase, source, uploadTelemetry = true) {
-    const config = (0, utils_1.readConfig)();
-    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
-        return;
-    const policy = (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId);
-    const sessionId = hookInput.session_id ?? hookInput.sessionId;
-    const sessionSignal = phase === "pre" ? (0, securitySession_1.readSessionSecuritySignal)(sessionId) : undefined;
-    const localDecision = (0, security_1.evaluateToolSecurity)(hookInput, phase, policy, source, sessionSignal);
-    if (phase === "post" && (0, security_1.securityInputHasSensitivePath)(hookInput)) {
-        (0, securitySession_1.recordSensitiveReadSignal)(sessionId);
-    }
-    const event = (0, security_1.buildSecurityWorkflowEvent)(hookInput, phase, source);
-    if (event) {
-        event.localDecision = localDecision.action;
-        event.localCategory = localDecision.category;
-    }
-    if (localDecision.action === "block" && phase === "pre") {
-        (0, captureLog_1.appendCaptureLog)({
-            stage: "security",
-            sessionId: hookInput.session_id ?? hookInput.sessionId ?? "unknown",
-            outcome: "ok",
-            detail: `phase=${phase} localDecision=block category=${localDecision.category}`,
-        });
-        if (uploadTelemetry)
-            dispatchSecurityEventUpload(event);
-        process.stdout.write(JSON.stringify({
-            hookSpecificOutput: {
-                hookEventName: "PreToolUse",
-                permissionDecision: "deny",
-                permissionDecisionReason: localDecision.reason,
-            },
-        }));
-        return;
-    }
-    if (!event)
-        return;
-    if (uploadTelemetry)
-        dispatchSecurityEventUpload(event);
-}
-function runPromptSecurityHook(hookInput, source, uploadTelemetry = true) {
-    const config = (0, utils_1.readConfig)();
-    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
-        return false;
-    const decision = (0, security_1.evaluatePromptSecurity)(hookInput.prompt, (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId), source);
-    if (decision.action !== "block")
-        return false;
-    (0, captureLog_1.appendCaptureLog)({
-        stage: "security",
-        sessionId: hookInput.session_id ?? hookInput.sessionId ?? "unknown",
-        outcome: "ok",
-        detail: `phase=prompt localDecision=block category=${decision.category} telemetry=${uploadTelemetry ? "enabled" : "suppressed"} cwd=${hookInput.cwd ?? "unknown"}`,
-    });
-    if (uploadTelemetry) {
-        dispatchSecurityEventUpload((0, security_1.buildBlockedSecurityPromptEvent)(hookInput, source, decision.category ?? "secret_in_prompt"));
-    }
-    process.stdout.write(JSON.stringify({
-        decision: "block",
-        reason: decision.reason,
-    }));
-    return true;
-}
-function dispatchAllowedPromptSecurityEvent(hookInput, source) {
-    const config = (0, utils_1.readConfig)();
-    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
-        return;
-    const event = (0, security_1.buildSecurityPromptEvent)(hookInput, source, Date.now, (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId));
-    if (event)
-        dispatchSecurityEventUpload(event);
-}
-function dispatchSecurityEventUpload(event) {
-    if (!event || !(0, securityFeature_1.isAgentSecurityEnabled)((0, utils_1.readConfig)()))
-        return;
-    try {
-        const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1], "security-upload"], {
-            detached: true,
-            stdio: ["pipe", "ignore", "ignore"],
-        });
-        child.stdin?.end(JSON.stringify(event));
-        child.unref();
-    }
-    catch {
-        // Telemetry is best-effort and must never delay local enforcement.
-    }
-}
-async function runSecurityEventUpload() {
-    const config = (0, utils_1.readConfig)();
-    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
-        return;
-    const startedAt = Date.now();
-    try {
-        const raw = await readStdin();
-        const event = JSON.parse(raw);
-        const eventWithEndpoint = (0, security_1.withEndpointIdentity)(event, {
-            endpointId: config.deviceId,
-            endpointName: config.deviceName,
-            cliVersion: version_1.CLI_VERSION,
-        });
-        const result = await postJsonForResponse(`${config.backendUrl}/api/cli/securityEvent`, { ...eventWithEndpoint }, config.token, 
-        // Leave room for a cold backend and durable scheduling. This uploader is
-        // detached, so the network budget never delays the developer's prompt or
-        // tool call. Policy refreshes use the separately signed sync endpoint.
-        5_000);
-        if (result?.policy?.schemaVersion === 1) {
-            (0, securityPolicy_1.writeEndpointSecurityPolicy)(result.policy, undefined, undefined, config.companyId);
-        }
-        (0, captureLog_1.appendCaptureLog)({
-            stage: "security",
-            sessionId: event.sessionId,
-            outcome: "ok",
-            detail: `phase=${event.phase} elapsedMs=${Date.now() - startedAt} verdict=${String(result?.verdict ?? "unknown")}`,
-        });
-    }
-    catch (err) {
-        (0, captureLog_1.appendCaptureLog)({
-            stage: "security",
-            sessionId: "upload",
-            outcome: "ERROR",
-            detail: `elapsedMs=${Date.now() - startedAt} ${err.message}`,
-        });
-    }
-}
 // Raw-bytes POST to a Convex storage upload URL (no auth header — the URL
 // itself is the one-time credential). Returns the parsed { storageId }.
 function postBytes(url, bytes, contentType) {
@@ -445,7 +324,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";
@@ -513,20 +392,6 @@ async function main() {
         }
         process.exit(0);
     }
-    // Daily component drift scan runs in a detached hook process. The parent
-    // SessionStart path only performs a timestamp read, so agent startup never
-    // waits for filesystem traversal or an inventory upload.
-    if (process.argv[2] === "security-inventory-upload") {
-        const config = (0, utils_1.readConfig)();
-        if (config && (0, securityFeature_1.isAgentSecurityEnabled)(config)) {
-            const inventory = (0, securityInventory_1.buildSecurityInventory)({ workspace: process.argv[3] || process.cwd() });
-            try {
-                await (0, securityInventory_1.uploadSecurityInventory)(inventory, config);
-            }
-            catch { /* retry after the daily inventory window */ }
-        }
-        process.exit(0);
-    }
     // Detached backup uploader child (spawned by runBackup below). The job file
     // carries only { root, files }; the child re-reads config from disk. No stdin
     // needed, so handle it before readStdin() like the capture uploader above.
@@ -563,78 +428,51 @@ async function main() {
         }
         process.exit(0);
     }
-    // Detached, best-effort security telemetry. Local policy decisions have
-    // already completed in the parent hook; this child can never delay or alter
-    // the developer's action.
-    if (process.argv[2] === "security-upload") {
-        await runSecurityEventUpload();
-        process.exit(0);
-    }
     let hookInput = {};
     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 {
         process.exit(0);
     }
-    // Privacy exclusions suppress every Codiedev upload, but they must never
-    // disable local security enforcement. Security hooks run first with telemetry
-    // 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))?$/);
-    if (securityMatch) {
-        const source = securityMatch[2] === "codex"
-            ? "codex"
-            : securityMatch[2] === "codie"
-                ? "codie-harness"
-                : "claude-code";
-        await runSecurityHook(hookInput, securityMatch[1], source, !captureIgnored);
+    // Local privacy boundary: every stdin-driven hook mode passes through this
+    // check BEFORE prompt discovery, limit-event tails, SessionStart pings,
+    // backup, self-heal, transcript reads, or detached dispatch. Ignored means
+    // no Codiedev request at all for this session.
+    if ((0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput)) {
         process.exit(0);
     }
     // UserPromptSubmit discovery path — separate from session capture.
-    const promptCommand = process.argv[2] ?? "";
     if (process.argv[2] === "discover" ||
         process.argv[2] === "discover-codex" ||
         process.argv[2] === "discover-codie") {
-        const source = promptCommand === "discover-codex"
-            ? "codex"
-            : promptCommand === "discover-codie"
-                ? "codie-harness"
-                : "claude-code";
-        // Security runs first and locally. A blocked prompt is erased before it
-        // reaches the model, so discovery must not send it to the backend.
-        if (runPromptSecurityHook(hookInput, source, !captureIgnored))
-            return;
-        if (captureIgnored)
-            return;
-        dispatchAllowedPromptSecurityEvent(hookInput, source);
         await runDiscover(hookInput.prompt);
         return;
     }
-    if (captureIgnored)
-        process.exit(0);
     // StopFailure (matcher rate_limit): post the rate-limit event.
     if (process.argv[2] === "limit") {
         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 ((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()], {
-                    detached: true,
-                    stdio: "ignore",
-                });
-                child.unref();
-            }
-            catch { /* daily inventory is best-effort */ }
-        }
-        await runSessionStart(hookInput, process.argv[2] === "session-start-opencode" ? "opencode" : "claude-code");
+    if (process.argv[2] === "session-start" ||
+        process.argv[2] === "session-start-cursor" ||
+        process.argv[2] === "session-start-opencode") {
+        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 +480,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 +500,13 @@ 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,
@@ -723,8 +568,8 @@ async function main() {
             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).
+            // close the server lease every turn. Cursor SessionEnd is final:true;
+            // Codex remains the legacy final-omitted per-turn path.
             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 +646,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 +660,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 +689,23 @@ 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);
+    // Never use parsed message count here: Cursor's private JSONL shape can
+    // evolve independently, and parser drift must not discard a real 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 server-side coverage while the session is alive.
+        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 +798,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 +806,10 @@ 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 });
+            // Persist the immediate payload before removing the older scheduled
+            // snapshot. Every immediate dispatch supersedes 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,12 @@
-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;
+/** Parse the structured rate-limit snapshot written to Codex rollout JSONL. */
+export declare function parseCodexLimitEventFromTranscript(transcript: string): LimitEvent | null;
 export declare function tailForLimitEvent(transcript: string, maxChars?: number): string;

package/dist/limitEvent.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyLimitKind = classifyLimitKind;
 exports.parseLimitEventFromTranscript = parseLimitEventFromTranscript;
+exports.parseCodexLimitEventFromTranscript = parseCodexLimitEventFromTranscript;
 exports.tailForLimitEvent = tailForLimitEvent;
 function classifyLimitKind(text) {
     const t = text.toLowerCase();
@@ -50,6 +51,59 @@ function parseLimitEventFromTranscript(transcript) {
     }
     return found;
 }
+function codexLimitKind(reason, spendControlReached) {
+    if (spendControlReached || reason.startsWith("workspace_owner_"))
+        return "org_spend";
+    if (reason.startsWith("workspace_member_"))
+        return "user_spend";
+    return reason === "rate_limit_reached" ? "session" : "other";
+}
+function codexResetText(rateLimits) {
+    const windows = [rateLimits?.primary, rateLimits?.secondary]
+        .filter((window) => window && typeof window === "object");
+    const reached = windows.filter((window) => Number(window.used_percent) >= 100);
+    const candidates = reached.length > 0 ? reached : windows;
+    const resetAt = candidates
+        .map((window) => Number(window.resets_at))
+        .filter((value) => Number.isFinite(value) && value > 0)
+        .sort((a, b) => a - b)[0];
+    return resetAt ? new Date(resetAt * 1000).toISOString() : null;
+}
+/** Parse the structured rate-limit snapshot written to Codex rollout JSONL. */
+function parseCodexLimitEventFromTranscript(transcript) {
+    let found = null;
+    for (const line of transcript.split("\n")) {
+        if (!line.includes('"rate_limit_reached_type"') && !line.includes('"spend_control_reached"'))
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry?.type !== "event_msg" || entry?.payload?.type !== "token_count")
+            continue;
+        const rateLimits = entry.payload.rate_limits;
+        if (!rateLimits || typeof rateLimits !== "object")
+            continue;
+        const reachedType = typeof rateLimits.rate_limit_reached_type === "string"
+            ? rateLimits.rate_limit_reached_type
+            : null;
+        const spendControlReached = rateLimits.spend_control_reached === true;
+        if (!reachedType && !spendControlReached)
+            continue;
+        const reason = reachedType ?? "spend_control_reached";
+        const at = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : NaN;
+        found = {
+            kind: codexLimitKind(reason, spendControlReached),
+            at: Number.isNaN(at) ? Date.now() : at,
+            resetText: codexResetText(rateLimits),
+            reason,
+        };
+    }
+    return found;
+}
 // Tail of the raw transcript to ship with the limit event so the server can
 // summarize "what they were working on" immediately — without waiting for the
 // SessionEnd capture (which can lag hours, or drop entirely on Windows).

package/dist/limitEventReporter.d.ts

@@ -0,0 +1,21 @@
+import { type LimitEvent } from "./limitEvent";
+export type LimitEventSource = "claude-code" | "codex";
+export type LimitEventPayload = LimitEvent & {
+    source: LimitEventSource;
+    sessionId?: string;
+    transcriptTail?: string;
+};
+export declare function postLimitEvent(config: {
+    backendUrl: string;
+    token: string;
+}, payload: LimitEventPayload, timeoutMs?: number): Promise<void>;
+export declare function reportTranscriptLimitEvent(args: {
+    config: {
+        backendUrl: string;
+        token: string;
+    };
+    source: LimitEventSource;
+    sessionId?: string;
+    transcript: string;
+    emitMinimalOnMiss?: boolean;
+}): Promise<boolean>;