codiedev 0.10.0-beta.1 → 0.10.0-beta.2

package/dist/captureLog.d.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 export declare const CAPTURE_LOG_MAX_BYTES: number;
 export declare const CAPTURE_LOG_PATH: string;
 export interface CaptureLogEntry {
-    stage: "capture-finish" | "upload" | "upload-deferred" | "security" | "stderr";
+    stage: "capture-finish" | "upload" | "upload-deferred" | "security" | "stderr" | "limit";
     sessionId: string | undefined;
     outcome: string;
     detail?: string;

package/dist/captureSignals.d.ts

@@ -0,0 +1,19 @@
+export declare const CAPTURE_SIGNALS_VERSION = 1;
+export type CaptureSignals = {
+    version: 1;
+    parsedRecords: number;
+    timestampCount: number;
+    firstAt?: number;
+    lastAt?: number;
+    activeMs: number;
+    idleThresholdMs: number;
+    skillInvocations: string[];
+    skillPulls: string[];
+    toolCalls: Array<{
+        name: string;
+        calls: number;
+    }>;
+    truncated: boolean;
+};
+/** Compact diagnostic inputs only: never persist prompts, commands or tool output. */
+export declare function parseCaptureSignals(content: string, source?: string): CaptureSignals;

package/dist/captureSignals.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAPTURE_SIGNALS_VERSION = void 0;
+exports.parseCaptureSignals = parseCaptureSignals;
+const transcriptModels_1 = require("./transcriptModels");
+exports.CAPTURE_SIGNALS_VERSION = 1;
+const IDLE_MS = 5 * 60_000;
+const LIMIT = 100;
+const skillKey = (value) => typeof value === "string"
+    ? value
+        .replace(/^\//, "")
+        .replace(/\.md$/i, "")
+        .replace(/["'`]/g, "")
+        .trim()
+        .toLowerCase()
+    : "";
+/** Compact diagnostic inputs only: never persist prompts, commands or tool output. */
+function parseCaptureSignals(content, source) {
+    const timestamps = new Set();
+    const invocations = new Set(), pulls = new Set();
+    const tools = new Map(), calls = new Set();
+    let parsedRecords = 0, truncated = false;
+    const addSkill = (set, value) => {
+        const key = skillKey(value);
+        if (!key || key.length > 200 || !/^[a-z0-9][a-z0-9_:/.-]*$/i.test(key))
+            return;
+        if (set.size >= LIMIT && !set.has(key)) {
+            truncated = true;
+            return;
+        }
+        set.add(key);
+    };
+    const command = (value) => {
+        if (typeof value !== "string")
+            return;
+        for (const match of value.matchAll(/\bcodiedev\s+pull\s+([^\s"'`]+)/gi))
+            addSkill(pulls, match[1]);
+    };
+    const tool = (name, id, input) => {
+        if (typeof name !== "string" || !name || name.length > 100)
+            return;
+        const key = typeof id === "string" ? id : `${parsedRecords}:${calls.size}`;
+        if (calls.has(key))
+            return;
+        calls.add(key);
+        if (tools.size < LIMIT || tools.has(name))
+            tools.set(name, (tools.get(name) ?? 0) + 1);
+        else
+            truncated = true;
+        let args = input;
+        if (typeof args === "string") {
+            try {
+                args = JSON.parse(args);
+            }
+            catch {
+                command(args);
+                return;
+            }
+        }
+        if (name.toLowerCase() === "skill")
+            addSkill(invocations, args?.skill ?? args?.name);
+        command(args?.command ?? args?.cmd);
+    };
+    for (const record of (0, transcriptModels_1.transcriptRecords)(content, source)) {
+        if (!record || typeof record !== "object")
+            continue;
+        const e = record;
+        parsedRecords++;
+        const time = typeof e.timestamp === "string"
+            ? Date.parse(e.timestamp)
+            : e.info?.time?.created;
+        if (typeof time === "number" && Number.isFinite(time) && time > 0)
+            timestamps.add(time);
+        const blocks = e.message?.content;
+        if (Array.isArray(blocks))
+            for (const part of blocks) {
+                if (part?.type === "tool_use")
+                    tool(part.name, part.id, part.input);
+                if (part?.type === "text" && e.type === "user") {
+                    for (const match of String(part.text ?? "").matchAll(/<command-name>\/?([a-z0-9:_-]+)<\/command-name>/gi))
+                        addSkill(invocations, match[1]);
+                }
+            }
+        if (typeof blocks === "string" && e.type === "user")
+            for (const match of blocks.matchAll(/<command-name>\/?([a-z0-9:_-]+)<\/command-name>/gi))
+                addSkill(invocations, match[1]);
+        if (e.type === "response_item" &&
+            ["function_call", "custom_tool_call"].includes(e.payload?.type))
+            tool(e.payload.name, e.payload.call_id, e.payload.arguments ?? e.payload.input);
+        if (e.info?.role === "assistant" && Array.isArray(e.parts))
+            for (const part of e.parts) {
+                if (part?.type === "tool")
+                    tool(part.tool, part.callID ?? part.id, part.state?.input);
+            }
+    }
+    const sorted = [...timestamps].sort((a, b) => a - b);
+    let activeMs = 0;
+    for (let i = 1; i < sorted.length; i++) {
+        const gap = sorted[i] - sorted[i - 1];
+        if (gap <= IDLE_MS)
+            activeMs += gap;
+    }
+    return {
+        version: exports.CAPTURE_SIGNALS_VERSION,
+        parsedRecords,
+        timestampCount: sorted.length,
+        ...(sorted.length
+            ? { firstAt: sorted[0], lastAt: sorted[sorted.length - 1] }
+            : {}),
+        activeMs,
+        idleThresholdMs: IDLE_MS,
+        skillInvocations: [...invocations].sort(),
+        skillPulls: [...pulls].sort(),
+        toolCalls: [...tools]
+            .map(([name, calls]) => ({ name, calls }))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+        truncated,
+    };
+}

package/dist/codexLimitScan.d.ts

@@ -0,0 +1,62 @@
+import { type LimitEvent } from "./limitEvent";
+import type { LimitEventPayload } from "./limitEventReporter";
+export interface CodexLimitHit {
+    event: LimitEvent;
+    /** Byte offset just past the matched line — the tail ends here, not at EOF. */
+    lineEnd: number;
+}
+export interface ScanOptions {
+    chunkSize?: number;
+    maxScanBytes?: number;
+}
+/**
+ * Find the LAST rate-limit/credit block recorded in a Codex rollout file.
+ * Returns null when the session was never blocked.
+ */
+export declare function scanCodexRolloutForLimit(filePath: string, options?: ScanOptions): CodexLimitHit | null;
+/**
+ * Read up to `maxBytes` of the rollout ENDING at `lineEnd` — the work the
+ * developer was doing when the block hit, not whatever the session did after
+ * the window reset. Resumes at a line boundary so every JSONL line parses.
+ */
+export declare function readTailEndingAt(filePath: string, lineEnd: number, maxBytes?: number): string;
+export interface FindRolloutOptions {
+    withinMs?: number;
+    maxFiles?: number;
+    now?: number;
+}
+/** Codex rollout files, newest first, limited by age and count. */
+export declare function findRecentCodexRollouts(sessionsDir: string, options?: FindRolloutOptions): string[];
+/** Codex names rollouts `rollout-<ISO local time>-<session id>.jsonl`. */
+export declare function sessionIdFromRolloutPath(filePath: string): string | undefined;
+/** Where Codex writes its rollout JSONL files. */
+export declare function codexSessionsDir(): string;
+export declare const CODEX_LIMIT_STATE_PATH: string;
+/**
+ * Record a block reported outside the sweep (the Stop path), so the next
+ * prompt sweep neither re-scans the rollout nor re-posts the event.
+ */
+export declare function recordCodexLimitReported(filePath: string, at: number, statePath?: string): void;
+export interface SweepArgs {
+    sessionsDir: string;
+    statePath?: string;
+    post: (payload: LimitEventPayload) => Promise<void>;
+    findOptions?: FindRolloutOptions;
+    scanOptions?: ScanOptions;
+    /** How many rollouts may actually be READ in one sweep. */
+    maxScans?: number;
+}
+/**
+ * Report every Codex block this machine has not reported yet. Returns how many
+ * events were posted. Never throws — it runs inside a hook.
+ *
+ * State is kept PER FILE, not as one newest-wins timestamp. A single global
+ * watermark loses data: rollouts are capped per sweep, so a block in a file
+ * outside the cap can be older than one already reported and would then be
+ * suppressed forever. A per-file record can only ever cause a re-report, which
+ * the server deduplicates on (companyId, userId, at).
+ *
+ * A file is recorded only after its POST succeeds, so a failed send is retried
+ * on the next prompt.
+ */
+export declare function sweepCodexLimits(args: SweepArgs): Promise<number>;

package/dist/codexLimitScan.js

@@ -0,0 +1,453 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEX_LIMIT_STATE_PATH = void 0;
+exports.scanCodexRolloutForLimit = scanCodexRolloutForLimit;
+exports.readTailEndingAt = readTailEndingAt;
+exports.findRecentCodexRollouts = findRecentCodexRollouts;
+exports.sessionIdFromRolloutPath = sessionIdFromRolloutPath;
+exports.codexSessionsDir = codexSessionsDir;
+exports.recordCodexLimitReported = recordCodexLimitReported;
+exports.sweepCodexLimits = sweepCodexLimits;
+// Reporting a Codex credit/rate-limit block.
+//
+// WHY THIS EXISTS: the `limit-codex` reporter is a Codex `Stop` hook, and
+// Codex does NOT run Stop hooks on the turn a block kills. Measured on real
+// rollouts: every normal `task_complete` pairs with a Stop-hook run within
+// ~200ms, and the blocked one never does (21 turns → 20 runs; 11 → 10, short
+// by exactly the blocked turn each time). Claude Code has a dedicated
+// StopFailure event with a `rate_limit` matcher, which is why it reports
+// correctly; Codex's HookEventName enum has no equivalent — there is no event
+// at all that fires at the block.
+//
+// So the block can only be reported LATER, from a hook that does run. This
+// module scans the rollout files Codex has already written and reports any
+// block that has not been reported yet. It is driven from UserPromptSubmit
+// (`discover-codex`), which fires on the developer's next prompt — in the
+// blocked session or in a new one — and from Stop, which still catches the
+// (rarer) case of a block followed by more turns.
+//
+// The scan reads BACKWARDS from end of file. The previous reader took a fixed
+// 512 KB tail, which silently lost the event whenever the session kept writing
+// after the block: in one real 44 MB rollout the marker sat 1.13 MB from the
+// end, outside the window, and the parse returned null.
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const limitEvent_1 = require("./limitEvent");
+const configDir_1 = require("./configDir");
+const MARKER = Buffer.from("rate_limit_reached_type");
+const SPEND_MARKER = Buffer.from("spend_control_reached");
+const NEWLINE = 0x0a;
+// Read backwards in 256 KB chunks, and give up after 16 MB. Codex rollouts run
+// to tens of megabytes, but a block is always in the session's LAST turn — the
+// bytes after it are whatever the session did once the window reset. 16 MB
+// covers that comfortably without ever loading a whole rollout.
+const DEFAULT_CHUNK_SIZE = 256 * 1024;
+const DEFAULT_MAX_SCAN_BYTES = 16 * 1024 * 1024;
+// Tail shipped to the server so it can summarize what the developer was doing
+// when they got blocked. Matches the server-side cap in http.ts.
+const DEFAULT_TAIL_BYTES = 64 * 1024;
+/**
+ * Find the LAST rate-limit/credit block recorded in a Codex rollout file.
+ * Returns null when the session was never blocked.
+ */
+function scanCodexRolloutForLimit(filePath, options = {}) {
+    const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
+    const maxScanBytes = options.maxScanBytes ?? DEFAULT_MAX_SCAN_BYTES;
+    let size = 0;
+    try {
+        size = fs.statSync(filePath).size;
+    }
+    catch {
+        return null;
+    }
+    if (size === 0)
+        return null;
+    let fd;
+    try {
+        fd = fs.openSync(filePath, "r");
+    }
+    catch {
+        return null;
+    }
+    try {
+        let pos = size;
+        // Bytes of the (earlier-read) chunk that belong to a line whose start we
+        // have not reached yet. Carried into the next, earlier chunk.
+        let carry = Buffer.alloc(0);
+        let scanned = 0;
+        while (pos > 0 && scanned < maxScanBytes) {
+            const length = Math.min(chunkSize, pos, maxScanBytes - scanned);
+            if (length <= 0)
+                break;
+            pos -= length;
+            const chunk = Buffer.allocUnsafe(length);
+            const read = fs.readSync(fd, chunk, 0, length, pos);
+            scanned += read;
+            const window = Buffer.concat([chunk.subarray(0, read), carry]);
+            // At pos > 0 the first line in the window is partial — its start lies in
+            // an earlier chunk — so hold it back rather than parse a torn line.
+            let completeStart = 0;
+            if (pos > 0) {
+                const firstNewline = window.indexOf(NEWLINE);
+                if (firstNewline < 0) {
+                    // The whole window is one unterminated line. A token_count record is
+                    // ~1 KB, so a line this long is never the one we want: drop it rather
+                    // than grow the carry without bound.
+                    carry = window.length > maxScanBytes ? Buffer.alloc(0) : window;
+                    continue;
+                }
+                completeStart = firstNewline + 1;
+                carry = window.subarray(0, completeStart);
+            }
+            else {
+                carry = Buffer.alloc(0);
+            }
+            const region = window.subarray(completeStart);
+            if (region.indexOf(MARKER) < 0 && region.indexOf(SPEND_MARKER) < 0)
+                continue;
+            // Walk this window's complete lines from the end backwards; the first
+            // match going backwards is the latest one in the file.
+            const bounds = [];
+            let lineStart = 0;
+            for (let index = 0; index < region.length; index += 1) {
+                if (region[index] === NEWLINE) {
+                    bounds.push([lineStart, index + 1]);
+                    lineStart = index + 1;
+                }
+            }
+            if (lineStart < region.length)
+                bounds.push([lineStart, region.length]);
+            for (let index = bounds.length - 1; index >= 0; index -= 1) {
+                const [start, end] = bounds[index];
+                const event = (0, limitEvent_1.parseCodexLimitEventFromTranscript)(region.subarray(start, end).toString("utf8"));
+                if (event)
+                    return { event, lineEnd: pos + completeStart + end };
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            fs.closeSync(fd);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}
+/**
+ * Read up to `maxBytes` of the rollout ENDING at `lineEnd` — the work the
+ * developer was doing when the block hit, not whatever the session did after
+ * the window reset. Resumes at a line boundary so every JSONL line parses.
+ */
+function readTailEndingAt(filePath, lineEnd, maxBytes = DEFAULT_TAIL_BYTES) {
+    // Clamp to the file as it is NOW: the offset came from an earlier scan, and
+    // reading past EOF would return a short, garbled tail.
+    let end = lineEnd;
+    try {
+        end = Math.min(lineEnd, fs.statSync(filePath).size);
+    }
+    catch {
+        return "";
+    }
+    const start = Math.max(0, end - maxBytes);
+    const length = end - start;
+    if (length <= 0)
+        return "";
+    let fd;
+    try {
+        fd = fs.openSync(filePath, "r");
+    }
+    catch {
+        return "";
+    }
+    try {
+        const buffer = Buffer.allocUnsafe(length);
+        const read = fs.readSync(fd, buffer, 0, length, start);
+        const text = buffer.subarray(0, read).toString("utf8");
+        if (start === 0)
+            return text;
+        const newline = text.indexOf("\n");
+        return newline === -1 ? "" : text.slice(newline + 1);
+    }
+    catch {
+        return "";
+    }
+    finally {
+        try {
+            fs.closeSync(fd);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}
+const DEFAULT_WITHIN_MS = 24 * 3600_000;
+const DEFAULT_MAX_FILES = 12;
+/** Codex rollout files, newest first, limited by age and count. */
+function findRecentCodexRollouts(sessionsDir, options = {}) {
+    const withinMs = options.withinMs ?? DEFAULT_WITHIN_MS;
+    const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+    const now = options.now ?? Date.now();
+    const found = [];
+    const walk = (directory, depth) => {
+        if (depth > 5)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+                continue;
+            try {
+                const mtime = fs.statSync(full).mtimeMs;
+                if (now - mtime > withinMs)
+                    continue;
+                found.push({ file: full, mtime });
+            }
+            catch {
+                /* unreadable — skip */
+            }
+        }
+    };
+    walk(sessionsDir, 0);
+    return found
+        .sort((left, right) => right.mtime - left.mtime)
+        .slice(0, maxFiles)
+        .map((entry) => entry.file);
+}
+/** Codex names rollouts `rollout-<ISO local time>-<session id>.jsonl`. */
+function sessionIdFromRolloutPath(filePath) {
+    const match = path.basename(filePath).match(/^rollout-.*?T[\d-]+-(.+)\.jsonl$/);
+    return match ? match[1] : undefined;
+}
+/** Where Codex writes its rollout JSONL files. */
+function codexSessionsDir() {
+    return path.join(os.homedir(), ".codex", "sessions");
+}
+exports.CODEX_LIMIT_STATE_PATH = path.join((0, configDir_1.codiedevStateDir)(), "codex-limit-state.json");
+// Bounds the state file on a machine with a long Codex history.
+const MAX_STATE_ENTRIES = 500;
+function readSweepState(statePath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    }
+    catch {
+        return { seen: {} };
+    }
+    const seen = {};
+    const raw = parsed.seen;
+    if (raw && typeof raw === "object") {
+        for (const [file, value] of Object.entries(raw)) {
+            const record = value;
+            if (typeof record?.size !== "number")
+                continue;
+            seen[file] = {
+                size: record.size,
+                mtime: typeof record.mtime === "number" ? record.mtime : -1,
+                at: typeof record.at === "number" ? record.at : null,
+                t: typeof record.t === "number" ? record.t : 0,
+            };
+        }
+    }
+    // Migrate the 0.10.0-beta shape ({ reportedThrough, clean }). The old global
+    // watermark is DELIBERATELY dropped rather than carried over: it is exactly
+    // what could suppress an older block forever. Re-reporting is safe — the
+    // server deduplicates on (companyId, userId, at).
+    const legacyClean = parsed.clean;
+    if (legacyClean && typeof legacyClean === "object") {
+        for (const [file, size] of Object.entries(legacyClean)) {
+            if (typeof size === "number" && !seen[file])
+                seen[file] = { size, mtime: -1, at: null, t: 0 };
+        }
+    }
+    return { seen };
+}
+// A record is dropped only once its file has been gone for a while. Pruning
+// the moment a path is missing would re-report an already-sent block after any
+// transient rename or move.
+const PRUNE_AFTER_MS = 7 * 24 * 3600_000;
+function pruneSweepState(state, now) {
+    for (const [file, record] of Object.entries(state.seen)) {
+        if (now - (record.t ?? 0) < PRUNE_AFTER_MS)
+            continue;
+        if (!fs.existsSync(file))
+            delete state.seen[file];
+    }
+    const files = Object.keys(state.seen);
+    if (files.length <= MAX_STATE_ENTRIES)
+        return;
+    files
+        .sort((left, right) => (state.seen[right].t ?? 0) - (state.seen[left].t ?? 0))
+        .slice(MAX_STATE_ENTRIES)
+        .forEach((file) => delete state.seen[file]);
+}
+/**
+ * Merge our records into whatever is on disk NOW and write the result. Two
+ * Codex sessions can submit a prompt at the same time; a plain
+ * read-modify-write would silently drop the other process's records.
+ */
+function commitSweepState(statePath, ours, now) {
+    const current = readSweepState(statePath);
+    for (const [file, record] of Object.entries(ours))
+        current.seen[file] = record;
+    pruneSweepState(current, now);
+    writeSweepState(statePath, current);
+}
+function writeSweepState(statePath, state) {
+    // Written through a temp file and renamed: Codex kills a hook that overruns
+    // its timeout, and a half-written state file would read as "nothing seen"
+    // and re-report every block in the window.
+    const temp = `${statePath}.${process.pid}.tmp`;
+    try {
+        fs.mkdirSync(path.dirname(statePath), { recursive: true });
+        fs.writeFileSync(temp, JSON.stringify(state), "utf8");
+        fs.renameSync(temp, statePath);
+    }
+    catch {
+        try {
+            fs.unlinkSync(temp);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}
+function fingerprint(filePath) {
+    try {
+        const stat = fs.statSync(filePath);
+        return { size: stat.size, mtime: stat.mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Record a block reported outside the sweep (the Stop path), so the next
+ * prompt sweep neither re-scans the rollout nor re-posts the event.
+ */
+function recordCodexLimitReported(filePath, at, statePath = exports.CODEX_LIMIT_STATE_PATH) {
+    const print = fingerprint(filePath);
+    if (!print)
+        return;
+    commitSweepState(statePath, { [filePath]: { ...print, at, t: Date.now() } }, Date.now());
+}
+// Candidates are listed generously and settled by one statSync each; only
+// files that actually changed cost a read. The budget therefore bounds work
+// without letting idle sessions bury an unreported block.
+const DEFAULT_CANDIDATES = 200;
+const DEFAULT_MAX_SCANS = 8;
+/**
+ * Report every Codex block this machine has not reported yet. Returns how many
+ * events were posted. Never throws — it runs inside a hook.
+ *
+ * State is kept PER FILE, not as one newest-wins timestamp. A single global
+ * watermark loses data: rollouts are capped per sweep, so a block in a file
+ * outside the cap can be older than one already reported and would then be
+ * suppressed forever. A per-file record can only ever cause a re-report, which
+ * the server deduplicates on (companyId, userId, at).
+ *
+ * A file is recorded only after its POST succeeds, so a failed send is retried
+ * on the next prompt.
+ */
+async function sweepCodexLimits(args) {
+    const statePath = args.statePath ?? exports.CODEX_LIMIT_STATE_PATH;
+    const state = readSweepState(statePath);
+    const files = findRecentCodexRollouts(args.sessionsDir, {
+        maxFiles: DEFAULT_CANDIDATES,
+        ...args.findOptions,
+    });
+    const now = Date.now();
+    const touched = {};
+    let budget = args.maxScans ?? DEFAULT_MAX_SCANS;
+    const pending = [];
+    for (const file of files) {
+        const print = fingerprint(file);
+        if (!print)
+            continue;
+        const record = state.seen[file];
+        // Settled by the stat alone — it has not changed since the last scan, so
+        // it holds nothing new and does not spend the read budget.
+        if (record && record.size === print.size && record.mtime === print.mtime)
+            continue;
+        if (budget <= 0)
+            break;
+        budget -= 1;
+        const hit = scanCodexRolloutForLimit(file, args.scanOptions);
+        if (!hit) {
+            touched[file] = { ...print, at: null, t: now };
+            continue;
+        }
+        if (record && record.at === hit.event.at) {
+            // Same block, already reported; the file just grew.
+            touched[file] = { ...print, at: record.at, t: now };
+            continue;
+        }
+        pending.push({ file, print, hit });
+    }
+    // Posted concurrently: each file is independent, and this runs on the
+    // prompt path where a serial chain of network timeouts would be felt.
+    const results = await Promise.allSettled(pending.map(({ file, hit }) => args.post({
+        source: "codex",
+        ...hit.event,
+        sessionId: sessionIdFromRolloutPath(file),
+        transcriptTail: readTailEndingAt(file, hit.lineEnd),
+    })));
+    let posted = 0;
+    results.forEach((result, index) => {
+        if (result.status !== "fulfilled")
+            return;
+        const { file, print, hit } = pending[index];
+        touched[file] = { ...print, at: hit.event.at, t: now };
+        posted += 1;
+    });
+    commitSweepState(statePath, touched, now);
+    return posted;
+}

package/dist/codieLauncher.js

@@ -56,6 +56,7 @@ exports.validateCodieArgs = validateCodieArgs;
 const path = __importStar(require("path"));
 const url_1 = require("url");
 const DEFAULT_NAMES = {
+    "openai/gpt-5.6-luna": "GPT-5.6 Luna",
     "openai/gpt-5.3-codex": "GPT-5.3 Codex",
     "openai/gpt-5.2-codex": "GPT-5.2 Codex",
     "openai/gpt-5.1-codex-mini": "GPT-5.1 Codex Mini",

package/dist/hook.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildDiscoveryContext = buildDiscoveryContext;
+const captureSignals_1 = require("./captureSignals");
+const transcriptModels_1 = require("./transcriptModels");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const https = __importStar(require("https"));
@@ -42,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 security_1 = require("./security");
@@ -148,10 +151,100 @@ 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),
+            // This runs on the prompt path, so keep it bounded. Unchanged rollouts
+            // cost one statSync and do not spend the read budget, so a busy machine
+            // cannot bury an unreported block behind newer idle sessions. When a
+            // block is still unreported it sits at the END of its rollout, so a
+            // small scan window is enough; the Stop path keeps the larger default
+            // for a session that kept going after the window reset.
+            findOptions: { withinMs: 24 * 3600_000 },
+            maxScans: 8,
+            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
@@ -646,6 +739,10 @@ async function main() {
         if (captureIgnored)
             return;
         dispatchAllowedPromptSecurityEvent(hookInput, source);
+        // 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 (source === "codex")
+            await runCodexLimitSweep(hookInput.session_id);
         await runDiscover(hookInput.prompt);
         return;
     }
@@ -970,6 +1067,8 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         cacheReadTokens: usage.cacheReadTokens,
         cacheCreationTokens: usage.cacheCreationTokens,
         model: usage.model,
+        captureSignals: (0, captureSignals_1.parseCaptureSignals)(mode === "desktop" || mode === "opencode" ? rawTranscriptContent : transcriptContent, mode),
+        modelUsage: (0, transcriptModels_1.parseTranscriptModels)(mode === "desktop" || mode === "opencode" ? rawTranscriptContent : transcriptContent, mode),
         sessionStartedAt,
         interruptCount: steering.interrupts,
         rejectionCount: steering.rejections,

package/dist/transcriptModels.d.ts

@@ -0,0 +1,18 @@
+/** Compact per-model usage, derived from captured transcript records. */
+export type TranscriptModelUsage = {
+    model: string;
+    /** Assistant message IDs; nonzero cumulative usage events for Codex. */
+    requests: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    costUsd?: number;
+    /** Reported provider figure, retained separately from trusted billing inputs. */
+    reportedCostUsd?: number;
+    /** Reported reasoning is included in outputTokens, never added again. */
+    reasoningTokens?: number;
+};
+export declare function transcriptRecords(content: string, source?: string): Generator<unknown>;
+export declare function parseTranscriptModels(content: string, source?: string): TranscriptModelUsage[];
+export declare function totalModelTokens(row: Omit<TranscriptModelUsage, "model" | "requests">): number;

package/dist/transcriptModels.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transcriptRecords = transcriptRecords;
+exports.parseTranscriptModels = parseTranscriptModels;
+exports.totalModelTokens = totalModelTokens;
+const positive = (n) => typeof n === "number" && Number.isFinite(n) ? Math.max(0, n) : 0;
+const empty = (model) => ({
+    model,
+    requests: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+});
+function* transcriptRecords(content, source) {
+    if (content.trimStart().startsWith("[") ||
+        ((source === "opencode" || source === "desktop") &&
+            content.trimStart().startsWith("{"))) {
+        try {
+            const parsed = JSON.parse(content);
+            const list = Array.isArray(parsed) ? parsed : parsed?.data;
+            if (Array.isArray(list)) {
+                yield* list;
+                return;
+            }
+        }
+        catch {
+            /* Fall through to JSONL for partial captures. */
+        }
+    }
+    let start = 0;
+    while (start < content.length) {
+        const newline = content.indexOf("\n", start);
+        const end = newline < 0 ? content.length : newline;
+        try {
+            yield JSON.parse(content.slice(start, end));
+        }
+        catch {
+            /* partial or non-JSON line */
+        }
+        start = end + 1;
+    }
+}
+function parseTranscriptModels(content, source) {
+    const buckets = new Map();
+    const messages = new Map();
+    let model = "Unattributed";
+    let previous = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+    };
+    let previousReasoning = 0;
+    let index = 0;
+    for (const record of transcriptRecords(content, source)) {
+        const event = record;
+        index++;
+        if (!event || typeof event !== "object")
+            continue;
+        let usage = null;
+        let messageId = String(index);
+        if (source === "codex") {
+            if (event.type === "turn_context" &&
+                typeof event.payload?.model === "string")
+                model = event.payload.model;
+            if (event.type !== "event_msg" || event.payload?.type !== "token_count")
+                continue;
+            const raw = event.payload?.info?.total_token_usage;
+            if (!raw)
+                continue;
+            const total = {
+                inputTokens: Math.max(0, positive(raw.input_tokens) - positive(raw.cached_input_tokens)),
+                outputTokens: positive(raw.output_tokens),
+                cacheReadTokens: positive(raw.cached_input_tokens),
+                cacheCreationTokens: 0,
+            };
+            // Codex reasoning_output_tokens is a subset of output_tokens. Cumulative
+            // snapshots must be differenced, including across a model switch.
+            usage = { ...empty(model), requests: 1 };
+            const reset = positive(raw.input_tokens) <
+                previous.inputTokens + previous.cacheReadTokens ||
+                total.outputTokens < previous.outputTokens;
+            for (const key of [
+                "inputTokens",
+                "outputTokens",
+                "cacheReadTokens",
+                "cacheCreationTokens",
+            ])
+                usage[key] = reset
+                    ? total[key]
+                    : Math.max(0, total[key] - previous[key]);
+            const reasoning = typeof raw.reasoning_output_tokens === "number" &&
+                raw.reasoning_output_tokens >= 0 &&
+                raw.reasoning_output_tokens <= total.outputTokens
+                ? raw.reasoning_output_tokens
+                : undefined;
+            if (reasoning !== undefined &&
+                (reset || previousReasoning !== undefined)) {
+                const delta = reset
+                    ? reasoning
+                    : Math.max(0, reasoning - previousReasoning);
+                if (delta <= usage.outputTokens)
+                    usage.reasoningTokens = delta;
+            }
+            previousReasoning = reasoning;
+            previous = total;
+            if (!totalModelTokens(usage))
+                continue;
+        }
+        else if (event.info?.role === "assistant") {
+            const info = event.info, tokens = info.tokens;
+            if (!tokens)
+                continue;
+            const id = typeof info.modelID === "string" ? info.modelID : "Unattributed";
+            model =
+                info.providerID && id !== "Unattributed"
+                    ? `${info.providerID}/${id}`
+                    : id;
+            usage = {
+                ...empty(model),
+                requests: 1,
+                inputTokens: positive(tokens.input),
+                outputTokens: positive(tokens.output) + positive(tokens.reasoning),
+                ...(typeof tokens.reasoning === "number"
+                    ? { reasoningTokens: positive(tokens.reasoning) }
+                    : {}),
+                cacheReadTokens: positive(tokens.cache?.read),
+                cacheCreationTokens: positive(tokens.cache?.write),
+                ...(typeof info.cost === "number"
+                    ? {
+                        reportedCostUsd: positive(info.cost),
+                        ...(source === "desktop" ? { costUsd: positive(info.cost) } : {}),
+                    }
+                    : {}),
+            };
+            messageId = info.id ?? messageId;
+        }
+        else {
+            const message = event.message;
+            if (!message?.usage)
+                continue;
+            model =
+                typeof message.model === "string" ? message.model : "Unattributed";
+            const raw = message.usage;
+            usage = {
+                ...empty(model),
+                requests: 1,
+                inputTokens: positive(raw.input_tokens),
+                outputTokens: positive(raw.output_tokens),
+                cacheReadTokens: positive(raw.cache_read_input_tokens),
+                cacheCreationTokens: positive(raw.cache_creation_input_tokens),
+            };
+            messageId = message.id ?? event.uuid ?? messageId;
+        }
+        // Client placeholders are not model executions.
+        if (!usage.model.trim() || usage.model.startsWith("<"))
+            continue;
+        // Streaming snapshots repeat message ids; retain the latest snapshot once.
+        messages.set(messageId, usage);
+    }
+    const incompleteCosts = new Set();
+    const incompleteReasoning = new Set();
+    const incompleteReportedCosts = new Set();
+    for (const usage of messages.values()) {
+        const key = buckets.has(usage.model) || buckets.size < 63
+            ? usage.model
+            : "Unattributed";
+        const bucket = buckets.get(key) ?? empty(key);
+        for (const field of [
+            "requests",
+            "inputTokens",
+            "outputTokens",
+            "cacheReadTokens",
+            "cacheCreationTokens",
+        ])
+            bucket[field] += usage[field];
+        if (usage.reasoningTokens !== undefined)
+            bucket.reasoningTokens =
+                (bucket.reasoningTokens ?? 0) + usage.reasoningTokens;
+        else
+            incompleteReasoning.add(key);
+        if (usage.reportedCostUsd !== undefined)
+            bucket.reportedCostUsd =
+                (bucket.reportedCostUsd ?? 0) + usage.reportedCostUsd;
+        else
+            incompleteReportedCosts.add(key);
+        if (usage.costUsd !== undefined)
+            bucket.costUsd = (bucket.costUsd ?? 0) + usage.costUsd;
+        else
+            incompleteCosts.add(key);
+        buckets.set(key, bucket);
+    }
+    for (const key of incompleteReportedCosts)
+        delete buckets.get(key).reportedCostUsd;
+    for (const key of incompleteCosts)
+        delete buckets.get(key).costUsd;
+    for (const key of incompleteReasoning)
+        delete buckets.get(key).reasoningTokens;
+    return [...buckets.values()];
+}
+function totalModelTokens(row) {
+    return (row.inputTokens +
+        row.outputTokens +
+        row.cacheReadTokens +
+        row.cacheCreationTokens);
+}

package/dist/utils.d.ts

@@ -1,4 +1,6 @@
 import * as fs from "fs";
+import type { CaptureSignals } from "./captureSignals";
+import type { TranscriptModelUsage } from "./transcriptModels";
 import { spawn as nodeSpawn } from "child_process";
 import type { CaptureLogEntry } from "./captureLog";
 import { codiedevStateDir } from "./configDir";
@@ -59,6 +61,8 @@ export declare function parseAuthoredShas(transcriptContent: string, repoRoot: s
 export declare function getGitBranch(cwd: string): string | null;
 export declare function getGitHeadSha(cwd: string): string | null;
 export interface CapturePayloadInput {
+    modelUsage?: TranscriptModelUsage[];
+    captureSignals?: CaptureSignals;
     sessionId?: string;
     transcriptBase64: string;
     remoteUrl: string | null;

package/dist/utils.js

@@ -854,6 +854,8 @@ function buildCapturePayload(input) {
         cacheReadTokens: input.cacheReadTokens,
         cacheCreationTokens: input.cacheCreationTokens,
         model: input.model ?? undefined,
+        modelUsage: input.modelUsage?.length ? input.modelUsage : undefined,
+        captureSignals: input.captureSignals,
         sessionStartedAt: input.sessionStartedAt ?? undefined,
         interruptCount: input.interruptCount,
         rejectionCount: input.rejectionCount,
@@ -2195,7 +2197,8 @@ function parseCodexUsage(content) {
     const input = last.input_tokens ?? 0;
     return {
         inputTokens: Math.max(0, input - cached),
-        outputTokens: (last.output_tokens ?? 0) + (last.reasoning_output_tokens ?? 0),
+        // Reasoning is included in output_tokens, not additional output.
+        outputTokens: last.output_tokens ?? 0,
         // Codex only reports cached reads; creation is structurally zero.
         cacheTokens: cached,
         cacheReadTokens: cached,
@@ -2399,6 +2402,8 @@ function normalizeOpenCodeTranscript(content) {
 //   {type:"response_item", payload:{type:"message", role, content:[{type:"input_text",text}|{type:"output_text",text}]}}
 //   {type:"response_item", payload:{type:"function_call", name, arguments, call_id}}
 //   {type:"response_item", payload:{type:"function_call_output", call_id, output}}
+//   {type:"response_item", payload:{type:"custom_tool_call", name, input, call_id}}
+//   {type:"response_item", payload:{type:"custom_tool_call_output", call_id, output}}
 //   {type:"event_msg", payload:{type:"token_count"|"agent_reasoning"|...}}
 //   {type:"turn_context", payload:{cwd, model, ...}}
 function parseCodexStats(content) {
@@ -2416,7 +2421,7 @@ function parseCodexStats(content) {
             if (payloadType === "message") {
                 messageCount++;
             }
-            else if (payloadType === "function_call") {
+            else if (payloadType === "function_call" || payloadType === "custom_tool_call") {
                 toolCallCount++;
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.10.0-beta.1",
+  "version": "0.10.0-beta.2",
   "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",