codiedev 0.9.55 → 0.9.57

package/dist/hook.js

@@ -44,6 +44,7 @@ const http = __importStar(require("http"));
 const child_process_1 = require("child_process");
 const utils_1 = require("./utils");
 const limitEventReporter_1 = require("./limitEventReporter");
+const codexLimitScan_1 = require("./codexLimitScan");
 const version_1 = require("./version");
 const captureLog_1 = require("./captureLog");
 const captureExclusions_1 = require("./captureExclusions");
@@ -143,10 +144,96 @@ async function runStopFailure(hookInput) {
     await readAndPostLimitEvent(hookInput, "claude-code", true);
     process.exit(0);
 }
+// Codex path. Two things differ from Claude Code:
+//
+// 1. There is no event that fires when a credit/rate-limit block kills a turn.
+//    Codex skips its Stop hook for exactly that turn (measured: every normal
+//    task_complete pairs with a Stop-hook run, the blocked one never does),
+//    and its HookEventName enum has no StopFailure equivalent. So the block is
+//    reported from the developer's NEXT prompt instead — see runCodexLimitSweep.
+// 2. Rollouts run to tens of megabytes and keep growing after the block, so a
+//    fixed tail read loses the marker (in one real 44 MB rollout it sat 1.13 MB
+//    from the end). Scan backwards for it instead.
+async function reportCodexLimitFromFile(config, transcriptPath, sessionId) {
+    const hit = (0, codexLimitScan_1.scanCodexRolloutForLimit)(transcriptPath);
+    if (!hit)
+        return false;
+    await (0, limitEventReporter_1.postLimitEvent)(config, {
+        source: "codex",
+        ...hit.event,
+        sessionId: sessionId ?? (0, codexLimitScan_1.sessionIdFromRolloutPath)(transcriptPath),
+        transcriptTail: (0, codexLimitScan_1.readTailEndingAt)(transcriptPath, hit.lineEnd),
+    });
+    // Tell the prompt sweep this one is done, so it neither re-scans the
+    // rollout nor re-posts an event the server would only deduplicate.
+    (0, codexLimitScan_1.recordCodexLimitReported)(transcriptPath, hit.event.at);
+    return true;
+}
 async function runCodexLimit(hookInput) {
-    await readAndPostLimitEvent(hookInput, "codex", false);
+    const config = (0, utils_1.readConfig)();
+    const transcriptPath = hookInput.transcript_path;
+    if (config && transcriptPath) {
+        try {
+            const sent = await reportCodexLimitFromFile(config, transcriptPath, hookInput.session_id);
+            if (sent) {
+                (0, captureLog_1.appendCaptureLog)({
+                    stage: "limit",
+                    sessionId: hookInput.session_id,
+                    outcome: "ok",
+                    detail: "source=codex trigger=stop",
+                });
+            }
+        }
+        catch (err) {
+            (0, captureLog_1.appendCaptureLog)({
+                stage: "limit",
+                sessionId: hookInput.session_id,
+                outcome: "ERROR",
+                detail: `source=codex trigger=stop ${err.message}`,
+            });
+        }
+    }
     process.exit(0);
 }
+const PROMPT_LIMIT_POST_TIMEOUT_MS = 2_500;
+// UserPromptSubmit: the first Codiedev hook that runs after a block, because
+// Codex runs no hook at the block itself. Scans the recent rollouts for any
+// block not yet reported. Cheap in the normal case — a per-file size cache
+// means an unchanged, unblocked rollout costs one statSync.
+async function runCodexLimitSweep(sessionId) {
+    const config = (0, utils_1.readConfig)();
+    if (!config)
+        return;
+    try {
+        const posted = await (0, codexLimitScan_1.sweepCodexLimits)({
+            sessionsDir: (0, codexLimitScan_1.codexSessionsDir)(),
+            // A shorter timeout than the default: this is on the user's prompt
+            // clock, and the next prompt retries anything that does not land.
+            post: (payload) => (0, limitEventReporter_1.postLimitEvent)(config, payload, PROMPT_LIMIT_POST_TIMEOUT_MS),
+            // Unchanged rollouts cost one statSync and do not spend the read
+            // budget, so in steady state this is nearly free. The module default
+            // covers a cold start; see DEFAULT_MAX_SCANS for why it is not small.
+            findOptions: { withinMs: 24 * 3600_000 },
+            scanOptions: { maxScanBytes: 4 * 1024 * 1024 },
+        });
+        if (posted > 0) {
+            (0, captureLog_1.appendCaptureLog)({
+                stage: "limit",
+                sessionId,
+                outcome: "ok",
+                detail: `source=codex trigger=prompt events=${posted}`,
+            });
+        }
+    }
+    catch (err) {
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "limit",
+            sessionId,
+            outcome: "ERROR",
+            detail: `source=codex trigger=prompt ${err.message}`,
+        });
+    }
+}
 // Skip-reason ping: this session is ending WITHOUT a capture, and here's why.
 // Turns silent coverage loss into per-reason buckets on the admin Capture
 // Health panel (patches the session's aiSessionStarts row server-side). Tiny
@@ -454,6 +541,11 @@ async function main() {
     if (process.argv[2] === "discover" ||
         process.argv[2] === "discover-codex" ||
         process.argv[2] === "discover-codie") {
+        // A Codex block leaves no hook of its own, so this prompt is the first
+        // chance to report it. Runs before runDiscover, which exits the process.
+        if (process.argv[2] === "discover-codex") {
+            await runCodexLimitSweep(hookInput.session_id);
+        }
         await runDiscover(hookInput.prompt);
         return;
     }

package/dist/limitEvent.js

@@ -51,11 +51,36 @@ function parseLimitEventFromTranscript(transcript) {
     }
     return found;
 }
+/**
+ * Codex's `rate_limit_reached_type` is exactly five values (read off the 0.154
+ * binary): `rate_limit_reached`, `workspace_{owner,member}_credits_depleted`
+ * and `workspace_{owner,member}_usage_limit_reached`.
+ *
+ * The split that matters to a reader of the dashboard is "someone must act on
+ * money" vs "this dev is throttled and it will reset" — so map on what the
+ * snapshot actually asserts, not on the word "credits":
+ *
+ * - A member out of their OWN allowance is a rate limit. Real snapshots carry
+ *   `spend_control_reached: null` and `individual_limit: null` — nobody
+ *   configured a budget, the window is simply used up. Calling that personal
+ *   spend tells a manager the dev overspent, which is not what happened.
+ *
+ *   Deliberately NOT gated on `individual_limit`: it has only ever been
+ *   observed null, so its populated shape and meaning are unknown, and a
+ *   wrong guess reinstates the mislabel this exists to remove. The reason
+ *   string is the causal signal; `individual_limit` is at best correlative.
+ * - A member whose ADMIN capped them (`usage_limit_reached`) is personal spend:
+ *   there really is a cap, and someone can raise it.
+ * - Anything owner-scoped is org spend — the org's allowance or credits are
+ *   gone and somebody has to act.
+ */
 function codexLimitKind(reason, spendControlReached) {
     if (spendControlReached || reason.startsWith("workspace_owner_"))
         return "org_spend";
-    if (reason.startsWith("workspace_member_"))
+    if (reason === "workspace_member_usage_limit_reached")
         return "user_spend";
+    if (reason === "workspace_member_credits_depleted")
+        return "session";
     return reason === "rate_limit_reached" ? "session" : "other";
 }
 function codexResetText(rateLimits) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.55",
+  "version": "0.9.57",
   "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",