codiedev 0.9.53 → 0.9.55

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/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"));
@@ -764,6 +766,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";
@@ -58,6 +60,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

@@ -853,6 +853,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,
@@ -2047,7 +2049,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,
@@ -2268,7 +2271,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.9.53",
+  "version": "0.9.55",
   "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",