codiedev 0.9.7-beta.0 → 0.9.7

package/dist/hook.js

@@ -256,6 +256,11 @@ async function main() {
     // server-side against a merged MR/PR's source_branch / commits for AI attribution.
     const branch = (0, utils_1.getGitBranch)(workspaceRoot);
     const headSha = (0, utils_1.getGitHeadSha)(workspaceRoot);
+    // Cost/velocity/steering signals parsed straight from the transcript we're
+    // already holding — no extra hooks, no extra git/process calls.
+    const usage = (0, utils_1.parseUsage)(transcriptContent, mode);
+    const sessionStartedAt = (0, utils_1.parseSessionStart)(transcriptContent);
+    const steering = (0, utils_1.parseSteering)(transcriptContent, mode);
     const payload = (0, utils_1.buildCapturePayload)({
         sessionId: session_id,
         transcriptBase64,
@@ -268,6 +273,13 @@ async function main() {
         source: mode,
         branch,
         headSha,
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheTokens: usage.cacheTokens,
+        model: usage.model,
+        sessionStartedAt,
+        interruptCount: steering.interrupts,
+        rejectionCount: steering.rejections,
     });
     // Fire the upload from a fully detached child and exit immediately. Awaiting
     // it inline let Claude Code's SessionEnd shutdown window elapse and kill the

package/dist/utils.d.ts

@@ -41,6 +41,13 @@ export interface CapturePayloadInput {
     source: string;
     branch?: string | null;
     headSha?: string | null;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheTokens?: number;
+    model?: string | null;
+    sessionStartedAt?: number | null;
+    interruptCount?: number;
+    rejectionCount?: number;
 }
 export declare function buildCapturePayload(input: CapturePayloadInput): Record<string, unknown>;
 export declare function hashToken(token: string): string;
@@ -119,6 +126,21 @@ export interface ParsedStats {
     messageCount: number;
     toolCallCount: number;
 }
+export interface SteeringStats {
+    interrupts: number;
+    rejections: number;
+}
+export declare function parseClaudeSteering(content: string): SteeringStats;
+export declare function parseCodexSteering(content: string): SteeringStats;
+export declare function parseSteering(content: string, mode: "claude-code" | "codex" | "cursor"): SteeringStats;
+export interface UsageStats {
+    inputTokens: number;
+    outputTokens: number;
+    cacheTokens: number;
+    model: string | null;
+}
+export declare function parseUsage(content: string, mode: "claude-code" | "codex" | "cursor"): UsageStats;
+export declare function parseSessionStart(content: string): number | null;
 export declare function parseClaudeCodeStats(content: string): ParsedStats;
 export declare function parseCodexStats(content: string): ParsedStats;
 export declare function extractCodexRepoUrl(content: string): string | null;

package/dist/utils.js

@@ -65,6 +65,11 @@ exports.cleanupCodexMcp = cleanupCodexMcp;
 exports.installCodexMcp = installCodexMcp;
 exports.installCodexHook = installCodexHook;
 exports.installCursorHook = installCursorHook;
+exports.parseClaudeSteering = parseClaudeSteering;
+exports.parseCodexSteering = parseCodexSteering;
+exports.parseSteering = parseSteering;
+exports.parseUsage = parseUsage;
+exports.parseSessionStart = parseSessionStart;
 exports.parseClaudeCodeStats = parseClaudeCodeStats;
 exports.parseCodexStats = parseCodexStats;
 exports.extractCodexRepoUrl = extractCodexRepoUrl;
@@ -349,6 +354,15 @@ function buildCapturePayload(input) {
         toolCallCount: input.toolCallCount,
         capturedAt: input.capturedAt,
         source: input.source,
+        // New capture signals (cost / velocity / steering). Optional — omitted
+        // (undefined) keys drop out of the JSON body, so older servers ignore them.
+        inputTokens: input.inputTokens,
+        outputTokens: input.outputTokens,
+        cacheTokens: input.cacheTokens,
+        model: input.model ?? undefined,
+        sessionStartedAt: input.sessionStartedAt ?? undefined,
+        interruptCount: input.interruptCount,
+        rejectionCount: input.rejectionCount,
     };
 }
 function hashToken(token) {
@@ -1032,6 +1046,137 @@ function installCursorHook() {
     hooks.sessionEnd = filtered;
     fs.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
 }
+function parseClaudeSteering(content) {
+    let interrupts = 0;
+    let rejections = 0;
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        // "[Request interrupted by user]" / "...for tool use" — Claude Code markers
+        if (line.includes("[Request interrupted by user"))
+            interrupts++;
+        // Standard Claude Code tool-rejection sentinels in tool_result content
+        if (line.includes("doesn't want to take this action") ||
+            line.includes("user doesn't want to proceed"))
+            rejections++;
+    }
+    return { interrupts, rejections };
+}
+function parseCodexSteering(content) {
+    let interrupts = 0;
+    let rejections = 0;
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            const pt = e?.payload?.type;
+            if (e?.type === "event_msg" && pt === "turn_aborted")
+                interrupts++;
+            if (e?.type === "response_item" && pt === "function_call_output") {
+                const out = String(e.payload?.output ?? "");
+                if (/\b(rejected|denied|not approved)\b/i.test(out))
+                    rejections++;
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return { interrupts, rejections };
+}
+function parseSteering(content, mode) {
+    return mode === "codex"
+        ? parseCodexSteering(content)
+        : parseClaudeSteering(content);
+}
+function parseClaudeUsage(content) {
+    // Claude Code logs per-turn usage; sum across the session. `input_tokens` is
+    // already fresh (cache read/creation are reported separately).
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheTokens = 0;
+    let model = null;
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            const m = e?.message;
+            const u = m?.usage;
+            if (u) {
+                inputTokens += u.input_tokens ?? 0;
+                outputTokens += u.output_tokens ?? 0;
+                cacheTokens += (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0);
+            }
+            if (typeof m?.model === "string" && m.model)
+                model = m.model;
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return { inputTokens, outputTokens, cacheTokens, model };
+}
+function parseCodexUsage(content) {
+    // Codex reports a CUMULATIVE token_count per turn — the last one is the
+    // session total. `input_tokens` includes the cached portion, so subtract it.
+    let model = null;
+    let last = null;
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (e?.type === "turn_context" && typeof e.payload?.model === "string" && e.payload.model) {
+                model = e.payload.model;
+            }
+            if (e?.type === "event_msg" && e.payload?.type === "token_count") {
+                const t = e.payload?.info?.total_token_usage;
+                if (t)
+                    last = t;
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    if (!last)
+        return { inputTokens: 0, outputTokens: 0, cacheTokens: 0, model };
+    const cached = last.cached_input_tokens ?? 0;
+    const input = last.input_tokens ?? 0;
+    return {
+        inputTokens: Math.max(0, input - cached),
+        outputTokens: (last.output_tokens ?? 0) + (last.reasoning_output_tokens ?? 0),
+        cacheTokens: cached,
+        model,
+    };
+}
+function parseUsage(content, mode) {
+    return mode === "codex" ? parseCodexUsage(content) : parseClaudeUsage(content);
+}
+// Lead-time start proxy: the earliest top-level `timestamp` in the transcript.
+// Both Claude Code and Codex stamp every line, so this is mode-agnostic.
+function parseSessionStart(content) {
+    let min = null;
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            const ts = e?.timestamp;
+            if (typeof ts === "string") {
+                const ms = Date.parse(ts);
+                if (!Number.isNaN(ms) && (min === null || ms < min))
+                    min = ms;
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return min;
+}
 function parseClaudeCodeStats(content) {
     let messageCount = 0;
     let toolCallCount = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.7-beta.0",
+  "version": "0.9.7",
   "description": "Connect Claude Code, Codex, Cursor, or VS Code Copilot to Codiedev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "dist/cli.js",