codiedev 0.9.60 → 0.9.62

package/dist/copilotHooks.js

@@ -0,0 +1,458 @@
+"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.COPILOT_VSCODE_CLIENT = void 0;
+exports.copilotHome = copilotHome;
+exports.copilotSessionDir = copilotSessionDir;
+exports.copilotTranscriptPath = copilotTranscriptPath;
+exports.parseCopilotWorkspace = parseCopilotWorkspace;
+exports.readCopilotWorkspace = readCopilotWorkspace;
+exports.copilotLaunch = copilotLaunch;
+exports.normalizeCopilotHookInput = normalizeCopilotHookInput;
+exports.copilotPreToolBlockResponse = copilotPreToolBlockResponse;
+exports.isCopilotTranscriptEmpty = isCopilotTranscriptEmpty;
+exports.hasCopilotShutdown = hasCopilotShutdown;
+exports.normalizeCopilotTranscript = normalizeCopilotTranscript;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+/**
+ * GitHub Copilot: VS Code Copilot Chat's agent and the Copilot CLI run on the
+ * same runtime and write the same session record,
+ * `$COPILOT_HOME/session-state/<sessionId>/events.jsonl` (plus
+ * `workspace.yaml`), and both read user hooks from `$COPILOT_HOME/hooks/*.json`.
+ * Everything Copilot-specific is translated here, at the process boundary, so
+ * the shared capture pipeline only ever sees the Claude-shaped transcript it
+ * already parses.
+ */
+/** `$COPILOT_HOME`, else `~/.copilot` (the runtime honours the same variable). */
+function copilotHome(env = process.env, home = os.homedir()) {
+    const override = env.COPILOT_HOME?.trim();
+    return override ? path.resolve(override) : path.join(home, ".copilot");
+}
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function copilotSessionDir(sessionId, home = copilotHome()) {
+    return SESSION_ID.test(sessionId) ? path.join(home, "session-state", sessionId) : undefined;
+}
+/** sessionEnd carries no transcript path; the session id names the file. */
+function copilotTranscriptPath(sessionId, home = copilotHome()) {
+    const dir = sessionId ? copilotSessionDir(sessionId, home) : undefined;
+    return dir ? path.join(dir, "events.jsonl") : undefined;
+}
+/** workspace.yaml is flat `key: value` lines; no YAML dependency needed. */
+function parseCopilotWorkspace(yaml) {
+    const fields = new Map();
+    for (const line of yaml.split(/\r?\n/)) {
+        const match = line.match(/^([a-z_]+):\s*(.*)$/);
+        if (!match)
+            continue;
+        let value = match[2].trim();
+        if (/^(["']).*\1$/.test(value))
+            value = value.slice(1, -1);
+        if (value)
+            fields.set(match[1], value);
+    }
+    const pick = (key) => fields.get(key);
+    return {
+        ...(pick("id") ? { id: pick("id") } : {}),
+        ...(pick("cwd") ? { cwd: pick("cwd") } : {}),
+        ...(pick("git_root") ? { gitRoot: pick("git_root") } : {}),
+        ...(pick("branch") ? { branch: pick("branch") } : {}),
+        ...(pick("client_name") ? { clientName: pick("client_name") } : {}),
+    };
+}
+/** The workspace.yaml beside a transcript (or for a session id); {} if absent. */
+function readCopilotWorkspace(transcriptPathOrDir) {
+    if (!transcriptPathOrDir)
+        return {};
+    const dir = transcriptPathOrDir.endsWith(".jsonl") ? path.dirname(transcriptPathOrDir) : transcriptPathOrDir;
+    try {
+        return parseCopilotWorkspace(fs.readFileSync(path.join(dir, "workspace.yaml"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+exports.COPILOT_VSCODE_CLIENT = "vscode-agent-host";
+const isVSCodeClient = (name) => name === exports.COPILOT_VSCODE_CLIENT || name === "vscode";
+/**
+ * How the session was launched. VS Code names itself in workspace.yaml; the
+ * CLI doesn't record whether it ran headless, so that comes from the process
+ * that launched the hook (`detected`, see launchContext). Unknown stays
+ * unknown rather than guessing "human".
+ */
+function copilotLaunch(clientName, detected) {
+    if (isVSCodeClient(clientName))
+        return "copilot:vscode";
+    return detected;
+}
+const firstString = (...values) => values.find((value) => typeof value === "string" && value.trim().length > 0);
+/**
+ * Copilot's hook payloads are camelCase (`sessionId`, `transcriptPath`,
+ * `toolName`/`toolArgs`/`toolResult`); preToolUse in the CLI batches calls as
+ * `toolCalls: [{id, name, args}]`. Translate to the shared snake_case shape.
+ * The FIRST tool call fills tool_name/tool_input; `copilotToolCalls` keeps all
+ * of them so security can check each.
+ */
+function normalizeCopilotHookInput(input, home = copilotHome()) {
+    const sessionId = firstString(input.session_id, input.sessionId);
+    const transcriptPath = firstString(input.transcript_path, input.transcriptPath)
+        ?? copilotTranscriptPath(sessionId, home);
+    const calls = copilotToolCalls(input);
+    const first = calls[0];
+    const toolResult = input.toolResult ?? input.tool_response;
+    return {
+        ...input,
+        ...(sessionId ? { session_id: sessionId } : {}),
+        ...(transcriptPath ? { transcript_path: transcriptPath } : {}),
+        ...(first ? { tool_name: first.name, tool_input: first.input } : {}),
+        ...(first?.id ? { tool_use_id: first.id } : {}),
+        ...(toolResult !== undefined ? { tool_response: toolResult } : {}),
+        ...(calls.length > 1 ? { copilotToolCalls: calls } : {}),
+    };
+}
+function copilotToolCalls(input) {
+    const parse = (args) => {
+        if (typeof args !== "string")
+            return args;
+        try {
+            return JSON.parse(args);
+        }
+        catch {
+            return args;
+        }
+    };
+    if (Array.isArray(input.toolCalls)) {
+        return input.toolCalls.flatMap((raw) => {
+            const call = raw;
+            const name = firstString(call?.name, call?.toolName);
+            return name
+                ? [{ ...(typeof call.id === "string" ? { id: call.id } : {}), name, input: parse(call.args ?? call.toolArgs) }]
+                : [];
+        });
+    }
+    const name = firstString(input.toolName, input.tool_name);
+    return name ? [{ name, input: parse(input.toolArgs ?? input.tool_input) }] : [];
+}
+/** Copilot's preToolUse deny output. */
+function copilotPreToolBlockResponse(reason) {
+    return { permissionDecision: "deny", permissionDecisionReason: reason };
+}
+/** Only a byte-empty record is safe to discard (same rule as Cursor). */
+function isCopilotTranscriptEmpty(content) {
+    return content.trim().length === 0;
+}
+/** session.shutdown carries the per-model token totals; written after sessionEnd. */
+function hasCopilotShutdown(content) {
+    return content.includes('"session.shutdown"');
+}
+// Copilot tool names → the Claude names the shared parsers key on (Bash
+// commands for git output and worktree dirs; Edit/Write for the dirs a session
+// wrote to). Anything else keeps Copilot's own name.
+function claudeTool(name, args) {
+    const a = (args && typeof args === "object" ? args : {});
+    const lower = name.toLowerCase();
+    const file = firstString(a.path, a.file_path, a.filePath);
+    if (lower === "bash" || lower === "shell" || lower === "powershell") {
+        return { name: "Bash", input: { ...a, command: firstString(a.command, a.cmd) ?? "" } };
+    }
+    if ((lower === "edit" || lower === "str_replace" || lower === "str_replace_editor" || lower === "apply_patch") && file) {
+        return { name: "Edit", input: { ...a, file_path: file } };
+    }
+    if ((lower === "create" || lower === "write") && file)
+        return { name: "Write", input: { ...a, file_path: file } };
+    if (lower === "view" && file)
+        return { name: "Read", input: { ...a, file_path: file } };
+    // The skill tool's runs are counted from skill.invoked (which also covers
+    // skills the user invoked directly); drop its argument so it isn't counted twice.
+    if (lower === "skill")
+        return { name: "skill", input: {} };
+    return { name, input: args ?? {} };
+}
+const num = (value) => (typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0);
+/** Image-only prompts have empty content. Keep attachment descriptions without
+ * reading local files, uploading image bytes, or inventing OCR prompt text. */
+function copilotUserContent(data) {
+    const content = [];
+    if (typeof data.content === "string" && data.content)
+        content.push({ type: "text", text: data.content });
+    if (Array.isArray(data.attachments)) {
+        for (const attachment of data.attachments) {
+            if (!attachment || typeof attachment !== "object")
+                continue;
+            const { displayName, mimeType, type } = attachment;
+            const name = typeof displayName === "string" ? displayName : "unnamed attachment";
+            const kind = typeof mimeType === "string" ? mimeType : typeof type === "string" ? type : "attachment";
+            content.push({ type: "text", text: `[Attachment: ${name} (${kind}); attachment contents unavailable in captured transcript]` });
+        }
+    }
+    return content.length ? content : [{ type: "text", text: "" }];
+}
+function resultText(data) {
+    const result = data.result;
+    if (typeof result === "string")
+        return result;
+    if (result && typeof result === "object") {
+        const { content, detailedContent } = result;
+        return [content, detailedContent].filter((v) => typeof v === "string").join("\n");
+    }
+    return typeof data.error?.message === "string" ? data.error.message : "";
+}
+const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+function premiumOf(data, at) {
+    return {
+        premiumRequests: count(data.totalPremiumRequests),
+        nanoAiu: count(data.totalNanoAiu),
+        ...(at ? { at } : {}),
+    };
+}
+function sumAgentMetrics(agents) {
+    const totals = {};
+    for (const metrics of agents) {
+        for (const [model, metric] of Object.entries(metrics ?? {})) {
+            const into = (totals[model] ??= {});
+            for (const [key, value] of Object.entries(metric?.usage ?? {}))
+                into[key] = (into[key] ?? 0) + num(value);
+        }
+    }
+    return Object.fromEntries(Object.entries(totals).map(([model, usage]) => [model, { usage }]));
+}
+/**
+ * events.jsonl → Claude-shaped JSONL:
+ *   session.start          → system record (cwd, branch, entrypoint for VS Code)
+ *   user.message           → user text
+ *   assistant.message      → assistant text + tool_use blocks (model on every call)
+ *   tool.execution_complete→ user tool_result (git output feeds branch/sha joins)
+ *   skill.invoked          → copilot.skill_invoked (one skill run)
+ *   session.shutdown       → copilot.usage per model (tokens, sub-agents
+ *                            included; requests counted from the assistant
+ *                            calls, so 0 here) + copilot.usage_summary
+ *   session.usage_checkpoint → copilot.usage_summary (premium requests and
+ *                            nano-AIU so far; superseded by shutdown)
+ *   subagent.started       → counted as a fleet sub-agent
+ * Hooks, permissions, system prompts and checkpoints are dropped.
+ */
+function normalizeCopilotTranscript(raw, opts = {}) {
+    const out = [];
+    const subagentCalls = new Set();
+    let shutdownAgents = 0;
+    let assistantModel = false;
+    // Copilot's subscription usage: the latest checkpoint, superseded by shutdown.
+    let premium;
+    let checkpointModels = [];
+    let final = false;
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const data = event?.data ?? {};
+        const timestamp = typeof event.timestamp === "string" ? event.timestamp : undefined;
+        const uuid = typeof event.id === "string" ? event.id : undefined;
+        const base = { ...(timestamp ? { timestamp } : {}), ...(uuid ? { uuid } : {}) };
+        switch (event.type) {
+            case "session.start": {
+                const context = data.context ?? {};
+                out.push(JSON.stringify({
+                    type: "system",
+                    subtype: "copilot_session_start",
+                    ...base,
+                    ...(typeof data.sessionId === "string" ? { sessionId: data.sessionId } : {}),
+                    ...(typeof context.cwd === "string" ? { cwd: context.cwd } : {}),
+                    ...(typeof context.branch === "string" ? { gitBranch: context.branch } : {}),
+                    ...(typeof data.copilotVersion === "string" ? { version: data.copilotVersion } : {}),
+                    ...(isVSCodeClient(opts.clientName) ? { entrypoint: "copilot:vscode" } : {}),
+                }));
+                break;
+            }
+            case "session.error":
+                out.push(JSON.stringify({ type: "agent.error", ...base, error: data.error ?? { message: data.message, code: data.errorType } }));
+                break;
+            case "hook.start":
+                if (data.hookType === "sessionEnd" && data.input?.reason === "abort") {
+                    out.push(JSON.stringify({ type: "agent.interruption", ...base, id: uuid }));
+                }
+                break;
+            case "user.message":
+                out.push(JSON.stringify({
+                    type: "user",
+                    ...base,
+                    message: { role: "user", content: copilotUserContent(data) },
+                }));
+                break;
+            case "subagent.started":
+                if (typeof data.toolCallId === "string")
+                    subagentCalls.add(data.toolCallId);
+                break;
+            case "session.usage_checkpoint":
+                if (!final)
+                    premium = premiumOf(data, timestamp);
+                if (Array.isArray(data.modelCacheState)) {
+                    checkpointModels = data.modelCacheState
+                        .map((m) => (m && typeof m === "object" ? m.modelId : undefined))
+                        .filter((m) => typeof m === "string" && m.length > 0);
+                }
+                break;
+            case "assistant.message": {
+                if (typeof data.model === "string" && data.model)
+                    assistantModel = true;
+                const tools = Array.isArray(data.toolRequests) ? data.toolRequests : [];
+                const content = [];
+                if (typeof data.content === "string" && data.content)
+                    content.push({ type: "text", text: data.content });
+                for (const request of tools) {
+                    if (typeof request?.name !== "string")
+                        continue;
+                    const mapped = claudeTool(request.name, request.arguments);
+                    content.push({ type: "tool_use", id: request.toolCallId, name: mapped.name, input: mapped.input });
+                }
+                out.push(JSON.stringify({
+                    type: "assistant",
+                    ...base,
+                    tokensAvailable: false,
+                    message: {
+                        id: firstString(data.apiCallId, data.messageId, uuid),
+                        role: "assistant",
+                        content,
+                        // One model call. Copilot reports tokens only at shutdown. A record
+                        // with no model is the runtime's own step (e.g. read_agent after a
+                        // fleet sub-agent finishes), not a model call, so it isn't counted.
+                        ...(typeof data.model === "string" && data.model
+                            ? {
+                                model: data.model,
+                                usage: { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 },
+                            }
+                            : {}),
+                    },
+                }));
+                break;
+            }
+            case "tool.execution_complete":
+                if (data.error?.code === "user_denied") {
+                    out.push(JSON.stringify({ type: "agent.rejection", ...base, id: data.toolCallId ?? uuid }));
+                }
+                // A space after the array bracket keeps the shared git-output scan
+                // (`[branch sha]` commit lines) from anchoring on JSON's own "[".
+                out.push(JSON.stringify({
+                    type: "user",
+                    ...base,
+                    message: {
+                        role: "user",
+                        content: [{
+                                type: "tool_result",
+                                tool_use_id: data.toolCallId,
+                                content: resultText(data),
+                                ...(data.success === false ? { is_error: true } : {}),
+                            }],
+                    },
+                }).replace('"content":[{', '"content":[ {'));
+                break;
+            case "skill.invoked":
+                if (typeof data.name === "string" && data.name) {
+                    out.push(JSON.stringify({ type: "copilot.skill_invoked", ...base, skill: data.name }));
+                }
+                break;
+            case "session.shutdown": {
+                final = true;
+                premium = premiumOf(data, timestamp);
+                const agents = Object.entries(data.agentMetrics ?? {});
+                shutdownAgents = agents.filter(([agent]) => agent !== "main").length;
+                // modelMetrics is the whole session, sub-agents included; older
+                // records without it are summed from the per-agent metrics.
+                const metrics = data.modelMetrics ?? sumAgentMetrics(agents.map(([, agent]) => agent?.modelMetrics));
+                for (const [model, metric] of Object.entries(metrics)) {
+                    const usage = metric?.usage ?? {};
+                    if (![usage.inputTokens, usage.outputTokens, usage.cacheReadTokens, usage.cacheWriteTokens].some(value => typeof value === "number" && Number.isFinite(value)))
+                        continue;
+                    const cacheRead = num(usage.cacheReadTokens);
+                    out.push(JSON.stringify({
+                        type: "copilot.usage",
+                        ...base,
+                        requests: 0,
+                        message: {
+                            id: `copilot-usage:${model}`,
+                            model,
+                            usage: {
+                                // Copilot's inputTokens include the cached prompt; the shared
+                                // shape counts fresh input separately from cache reads.
+                                input_tokens: Math.max(0, num(usage.inputTokens) - cacheRead),
+                                output_tokens: num(usage.outputTokens),
+                                cache_read_input_tokens: cacheRead,
+                                cache_creation_input_tokens: num(usage.cacheWriteTokens),
+                            },
+                        },
+                    }));
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    // No model on any assistant call (seen in open VS Code chats): name the
+    // models from the last checkpoint. No tokens are invented; requests stay 0.
+    if (!assistantModel) {
+        for (const model of checkpointModels) {
+            out.push(JSON.stringify({
+                type: "copilot.model",
+                tokensAvailable: false,
+                requests: 0,
+                message: {
+                    id: `copilot-model:${model}`,
+                    model,
+                    usage: { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 },
+                },
+            }));
+        }
+    }
+    if (premium && (premium.premiumRequests !== undefined || premium.nanoAiu !== undefined)) {
+        out.push(JSON.stringify({
+            type: "copilot.usage_summary",
+            ...(premium.at ? { timestamp: premium.at } : {}),
+            ...(premium.premiumRequests !== undefined ? { premiumRequests: premium.premiumRequests } : {}),
+            ...(premium.nanoAiu !== undefined ? { nanoAiu: premium.nanoAiu } : {}),
+        }));
+    }
+    return {
+        content: out.join("\n") + (out.length ? "\n" : ""),
+        subagents: { count: Math.max(subagentCalls.size, shutdownAgents), truncated: false },
+        final,
+    };
+}

package/dist/copilotInstallation.d.ts

@@ -0,0 +1,10 @@
+export declare function inspectCopilotHooks(file?: string, security?: boolean): {
+    status: "not-installed";
+    detail: string;
+} | {
+    status: "fail";
+    detail: string;
+} | {
+    status: "pass";
+    detail: string;
+};

package/dist/copilotInstallation.js

@@ -0,0 +1,65 @@
+"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.inspectCopilotHooks = inspectCopilotHooks;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const copilotHooks_1 = require("./copilotHooks");
+const detection_1 = require("./detection");
+function inspectCopilotHooks(file = path.join((0, copilotHooks_1.copilotHome)(), "hooks", "codiedev.json"), security = false) {
+    if (!fs.existsSync(file))
+        return { status: "not-installed", detail: `${file} not found` };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        const expected = security
+            ? [["userPromptSubmitted", "discover-copilot"], ["preToolUse", "security-pre-copilot"], ["postToolUse", "security-post-copilot"]]
+            : [["sessionStart", "session-start-copilot"], ["agentStop", "backup-copilot"], ["sessionEnd", "capture-copilot"], ["errorOccurred", "limit-copilot"]];
+        const missing = expected.filter(([event, subcommand]) => {
+            const entries = parsed.hooks?.[event];
+            return !Array.isArray(entries) || !entries.some((entry) => {
+                // Both platforms must have the managed command, not just the current one.
+                const commands = [entry.bash ?? entry.command, entry.powershell ?? entry.command];
+                return commands.every((command) => typeof command === "string"
+                    && (0, detection_1.isCodiedevHookCommand)(command) && command.trim().endsWith(subcommand));
+            });
+        }).map(([event]) => event);
+        if (parsed.version !== 1 || missing.length)
+            return { status: "fail", detail: `invalid or missing hooks: ${missing.join(", ") || "version"}` };
+        return { status: "pass", detail: security ? "prompt guard and tool telemetry hooks installed" : "session start, backup, capture and limit hooks installed" };
+    }
+    catch {
+        return { status: "fail", detail: "invalid Copilot hook configuration" };
+    }
+}

package/dist/cursorHooks.d.ts

@@ -1,9 +1,13 @@
 /** Normalize Cursor's native hook payload into the shared capture shape. */
 export declare function normalizeCursorHookInput<T extends Record<string, unknown>>(input: T): T & Record<string, unknown>;
-/** Add Claude-compatible message discriminators while preserving Cursor JSONL. */
+/** Normalize Cursor message roles and native tools at the capture boundary. */
 export declare function normalizeCursorTranscript(content: string): string;
 /** 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. */
 export declare function isCursorTranscriptEmpty(content: string): boolean;
+/** The IDE transcript often omits usage entirely; absence must not become
+ * measured zero. CLI records with explicit token fields retain their totals. */
+export declare function cursorTranscriptHasUsage(content: string): boolean;
+export declare function cursorObservedModel(content: string): string | undefined;

package/dist/cursorHooks.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeCursorHookInput = normalizeCursorHookInput;
 exports.normalizeCursorTranscript = normalizeCursorTranscript;
 exports.isCursorTranscriptEmpty = isCursorTranscriptEmpty;
+exports.cursorTranscriptHasUsage = cursorTranscriptHasUsage;
+exports.cursorObservedModel = cursorObservedModel;
 /** 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);
@@ -24,22 +26,37 @@ function normalizeCursorHookInput(input) {
         ...(duration !== undefined ? { duration_ms: duration } : {}),
     };
 }
-/** Add Claude-compatible message discriminators while preserving Cursor JSONL. */
+/** Normalize Cursor message roles and native tools at the capture boundary. */
 function normalizeCursorTranscript(content) {
-    return content.split("\n").map((line) => {
+    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 });
-            }
+            const type = entry.type ?? entry.role;
+            if (type !== "user" && type !== "assistant")
+                return line;
+            const message = entry.message;
+            const content = Array.isArray(message?.content) ? message.content.map((block) => {
+                if (!block || block.type !== "tool_use")
+                    return block;
+                const input = block.input ?? {};
+                const name = block.name === "Shell" ? "Bash" : block.name === "StrReplace" ? "Edit" : block.name;
+                return { ...block, name, input: { ...input,
+                        ...(typeof input.path === "string" && input.file_path === undefined ? { file_path: input.path } : {}),
+                    } };
+            }) : message?.content;
+            return JSON.stringify({ ...entry, type, ...(message ? { message: { ...message, content } } : {}) });
         }
         catch {
-            // Tolerant downstream parsers skip malformed/non-JSON lines.
+            // Preserve malformed/non-JSON lines; tolerant downstream parsers skip
+            // anything they cannot consume.
         }
         return line;
-    }).join("\n");
+    })
+        .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
@@ -54,3 +71,29 @@ function firstString(...values) {
 function firstNumber(...values) {
     return values.find((value) => typeof value === "number" && Number.isFinite(value));
 }
+/** The IDE transcript often omits usage entirely; absence must not become
+ * measured zero. CLI records with explicit token fields retain their totals. */
+function cursorTranscriptHasUsage(content) {
+    return content.split("\n").some((line) => {
+        try {
+            const usage = JSON.parse(line).message?.usage;
+            return usage && ["input_tokens", "output_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"]
+                .some((key) => typeof usage[key] === "number" && Number.isFinite(usage[key]));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function cursorObservedModel(content) {
+    let model;
+    for (const line of content.split("\n")) {
+        try {
+            const event = JSON.parse(line);
+            if (event.subtype === "cursor_model" && typeof event.model === "string")
+                model = event.model;
+        }
+        catch { /* partial records */ }
+    }
+    return model;
+}

package/dist/cursorLifecycle.d.ts

@@ -0,0 +1,2 @@
+export declare function recordCursorLifecycle(input: Record<string, unknown>, final: boolean): void;
+export declare function cursorLifecycleRecords(sessionId: string | undefined): string;