log-llm-config 1.5.0 → 1.5.8

package/dist/compliance_prompt_gate.js

@@ -6,7 +6,7 @@
  * When autofix returns restart_commands, this process does not spawn them — the shell hook pipes
  * the same JSON line to execute_trusted_restarts (TS allowlist + spawn).
  */
-import { applyAutofixViolations, confirmAppliedAutofixVerified, normalizeAgentToken, pruneSatisfiedOneTimeRemediations, reportPostRestartVerificationOutcomes, runLocalRemediationComplianceCheck, uploadSatisfiedManifestConfigs, } from './log_config_files/runtime/compliance_check.js';
+import { applyAutofixViolations, confirmAppliedAutofixVerified, normalizeAgentToken, pruneSatisfiedOneTimeRemediations, reportCompliantRemediationVerifiedStatus, reportPostRestartVerificationOutcomes, runLocalRemediationComplianceCheck, uploadSatisfiedManifestConfigs, } from './log_config_files/runtime/compliance_check.js';
 import { isRemediationQuarantined } from './log_config_files/runtime/remediation_apply_tracking.js';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { getRemediationInstructionsPath } from './log_config_files/runtime/management_storage.js';
@@ -16,8 +16,10 @@ import { finalizeAndUploadComplianceSessionLog, initComplianceSessionForGate, pa
 import { isThisCliModule } from './cli_invocation_match.js';
 import { ensureAuthentication } from './log_config_files/auth/auth_flow.js';
 import { sendConfigFile } from './log_config_files/sender/batch_sender.js';
+import { parseJsonWithJsoncFallback } from './log_config_files/readers/file_readers.js';
+import { PORTABLE_CURSOR_USER_SETTINGS, resolveRemediationConfigPath, resolveRemediationUploadFileType, } from './log_config_files/runtime/remediation_config_path.js';
 import { tryResolveHardwareUuid } from './log_config_files/runtime/hardware_uuid.js';
-import { syncRemediations } from './log_config_files/runtime/remediation_sync.js';
+import { cursorAutofixDefersInlineVerify, syncRemediations, } from './log_config_files/runtime/remediation_sync.js';
 import { loadEndpointBase } from './log_config_files/sender/endpoint_config.js';
 import { formatRemediationChangePreviewForApplied } from './remediation_change_preview.js';
 const MANIFEST_STALE_MS = 7 * 24 * 60 * 60 * 1000;
@@ -147,9 +149,9 @@ export function formatCopilotAutofixDialog(appliedViolations) {
 export function formatOpenCodeAutofixDialog(appliedViolations) {
     return formatPreventiveAutofixDialog(appliedViolations, 'OpenCode will now apply this policy to your environment.');
 }
-/** Cursor restart dialog after enforced/preventive remediation is applied locally. */
+/** Cursor restart after local autofix (all JSON settings + vscdb paths use restart_commands). */
 export function formatCursorRestartAutofixDialog(appliedViolations) {
-    return formatPreventiveAutofixDialog(appliedViolations, 'Cursor will now restart to apply this policy, and your context will be retained.');
+    return formatPreventiveAutofixDialog(appliedViolations, 'Cursor will restart so the running app reloads policy from disk. Your context will be retained.');
 }
 /**
  * Upload a secondary compliance file to the backend so the server can resolve the finding.
@@ -157,16 +159,23 @@ export function formatCursorRestartAutofixDialog(appliedViolations) {
  */
 async function _uploadSecondaryFile(entry) {
     const { uuid, config_file_path, file_type } = entry;
-    if (!file_type) {
+    const uploadFileType = resolveRemediationUploadFileType(config_file_path, file_type ?? undefined);
+    if (!uploadFileType) {
         hookRunLog(`secondary_upload: skipping uuid=${uuid} — no file_type on secondary group`);
         return;
     }
+    const diskPath = resolveRemediationConfigPath(config_file_path);
     let rawContent;
     try {
-        rawContent = JSON.parse(readFileSync(config_file_path, 'utf8'));
+        const parsed = parseJsonWithJsoncFallback(readFileSync(diskPath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            hookRunLog(`secondary_upload: invalid JSON uuid=${uuid} path=${diskPath}`);
+            return;
+        }
+        rawContent = parsed;
     }
     catch {
-        hookRunLog(`secondary_upload: could not read file uuid=${uuid} path=${config_file_path}`);
+        hookRunLog(`secondary_upload: could not read file uuid=${uuid} path=${diskPath}`);
         return;
     }
     const hw = tryResolveHardwareUuid();
@@ -174,13 +183,16 @@ async function _uploadSecondaryFile(entry) {
         hookRunLog(`secondary_upload: hardware UUID unavailable, skipping uuid=${uuid}`);
         return;
     }
+    const portablePath = config_file_path.includes('Cursor/User/settings.json')
+        ? PORTABLE_CURSOR_USER_SETTINGS
+        : config_file_path.trim() || diskPath;
     try {
         const authKey = await ensureAuthentication(hw);
-        const sent = await sendConfigFile({ file_type, file_path: config_file_path, raw_content: rawContent }, hw, authKey);
-        hookRunLog(`secondary_upload: uuid=${uuid} path=${config_file_path} sent=${sent}`);
+        const sent = await sendConfigFile({ file_type: uploadFileType, file_path: portablePath, raw_content: rawContent }, hw, authKey);
+        hookRunLog(`secondary_upload: uuid=${uuid} path=${portablePath} sent=${sent}`);
     }
     catch (err) {
-        hookRunLog(`secondary_upload: upload failed uuid=${uuid} path=${config_file_path} err=${err instanceof Error ? err.message : String(err)}`);
+        hookRunLog(`secondary_upload: upload failed uuid=${uuid} path=${portablePath} err=${err instanceof Error ? err.message : String(err)}`);
     }
 }
 /**
@@ -218,8 +230,6 @@ export async function runCompliancePromptGate() {
         hookLogSessionBanner('compliance_prompt_gate (before submit)');
     }
     let status = runLocalRemediationComplianceCheck(agent);
-    // Post-restart verify + server reports BEFORE sync so a manifest UUID swap cannot delay
-    // verified / activity-log until the following prompt.
     const postRestartVerify = reportPostRestartVerificationOutcomes(status.violations);
     if (postRestartVerify.outcomes.length > 0) {
         await Promise.allSettled(postRestartVerify.reportPromises);
@@ -306,12 +316,14 @@ export async function runCompliancePromptGate() {
                 // disk synchronously; a restart_command, if present, only reloads the already-compliant file
                 // into the running app — it is not the mechanism that makes the fix take effect. So report
                 // "verified" now instead of leaving the finding "pending" in the UI until the next prompt.
-                // Cursor's restart can carry a deferred state.vscdb write that only lands post-restart, so
-                // Cursor still verifies inline only when no restart is pending.
+                // Cursor JSON: disk recheck OK → verified before restart. Cursor deferred vscdb → verify after restart.
                 const immediateJsonAgent = ide === 'claude' || ide === 'copilot' || ide === 'opencode';
+                const diskProvenCompliant = recheckOk || claudeRecheckStaleAfterImmediateApply;
+                const cursorRestartVerifyPending = cursorAutofixDefersInlineVerify(ide, restartCommands.length, deferredSqlitePending === true, diskProvenCompliant);
                 const immediateVerified = !deferredSqlitePending &&
-                    (recheckOk || claudeRecheckStaleAfterImmediateApply) &&
-                    (restartCommands.length === 0 || immediateJsonAgent);
+                    !cursorRestartVerifyPending &&
+                    diskProvenCompliant &&
+                    (restartCommands.length === 0 || immediateJsonAgent || ide === 'cursor');
                 if (immediateVerified) {
                     confirmAppliedAutofixVerified(appliedViolations, reportPromises);
                     await Promise.allSettled(reportPromises);
@@ -376,6 +388,7 @@ export async function runCompliancePromptGate() {
         await Promise.allSettled(pruned.reportPromises);
     }
     await Promise.allSettled(uploadSatisfiedManifestConfigs(agent));
+    await Promise.allSettled(reportCompliantRemediationVerifiedStatus(agent));
     printAllow(ide);
 }
 if (isRunAsCliModule()) {

package/dist/log_config_files/collection/claude_token_usage_collector.js

@@ -0,0 +1,156 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+/**
+ * Token-usage / session / CLI-version aggregator for Claude Code.
+ *
+ * Claude Code writes one JSONL transcript per session under ~/.claude/projects/**. Each
+ * assistant line carries a `message.usage` block ({input,output,cache_*}_tokens), and every
+ * line carries the CLI `version` and `sessionId`. We aggregate the *numbers* (and version /
+ * model ids) on the endpoint and emit only those — never transcript content — so the backend
+ * gets token usage, session count, and a reliable CLI version without ingesting prompts.
+ *
+ * Bounded by mtime recency so a large transcript history (can be hundreds of MB) does not get
+ * fully re-parsed on every hook run; this yields "recent activity" usage and the current version.
+ */
+const TOKEN_USAGE_RECENCY_DAYS = 30;
+const TOKEN_USAGE_FILE_TYPE = 'claude_token_usage';
+function emptyTotals() {
+    return {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
+    };
+}
+function addUsage(totals, usage) {
+    for (const key of Object.keys(totals)) {
+        const value = usage[key];
+        if (typeof value === 'number' && Number.isFinite(value))
+            totals[key] += value;
+    }
+}
+/** Sum the token fields of one usage block (used for per-model attribution). */
+function usageSum(usage) {
+    let sum = 0;
+    for (const key of ['input_tokens', 'output_tokens', 'cache_creation_input_tokens', 'cache_read_input_tokens']) {
+        const value = usage[key];
+        if (typeof value === 'number' && Number.isFinite(value))
+            sum += value;
+    }
+    return sum;
+}
+/** Recursively collect *.jsonl files under a directory whose mtime is within the recency window. */
+function recentJsonlFiles(dir, cutoffMs) {
+    const out = [];
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...recentJsonlFiles(full, cutoffMs));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+            try {
+                if (statSync(full).mtimeMs >= cutoffMs)
+                    out.push(full);
+            }
+            catch {
+                /* unreadable file — skip */
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Aggregate token usage / session count / version across recent Claude session transcripts.
+ * Returns a single-element array (one per-machine aggregate) or [] when there is no recent data.
+ */
+function collectClaudeTokenUsage(home = homedir()) {
+    const projectsDir = join(home, '.claude', 'projects');
+    if (!existsSync(projectsDir))
+        return [];
+    const cutoffMs = Date.now() - TOKEN_USAGE_RECENCY_DAYS * 24 * 60 * 60 * 1000;
+    const files = recentJsonlFiles(projectsDir, cutoffMs);
+    if (files.length === 0)
+        return [];
+    const totals = emptyTotals();
+    const sessions = new Set();
+    const models = new Set();
+    const modelTokenSplit = {};
+    let version = '';
+    let versionAt = '';
+    let sawData = false;
+    for (const file of files) {
+        let content;
+        try {
+            content = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            sawData = true;
+            const sessionId = entry.sessionId;
+            if (typeof sessionId === 'string' && sessionId)
+                sessions.add(sessionId);
+            // Keep the version from the most recent line (timestamps are ISO-8601, sort lexically).
+            const lineVersion = entry.version;
+            const lineAt = typeof entry.timestamp === 'string' ? entry.timestamp : '';
+            if (typeof lineVersion === 'string' && lineVersion && lineAt >= versionAt) {
+                version = lineVersion;
+                versionAt = lineAt;
+            }
+            const message = entry.message;
+            if (message && typeof message === 'object') {
+                const msg = message;
+                // Skip Claude Code's internal placeholder model ids (e.g. "<synthetic>").
+                const model = typeof msg.model === 'string' && msg.model && !msg.model.startsWith('<') ? msg.model : '';
+                if (model)
+                    models.add(model);
+                if (msg.usage && typeof msg.usage === 'object') {
+                    const usage = msg.usage;
+                    addUsage(totals, usage);
+                    if (model) {
+                        const sum = usageSum(usage);
+                        if (sum > 0)
+                            modelTokenSplit[model] = (modelTokenSplit[model] ?? 0) + sum;
+                    }
+                }
+            }
+        }
+    }
+    if (!sawData)
+        return [];
+    return [
+        {
+            file_type: TOKEN_USAGE_FILE_TYPE,
+            // Stable synthetic path → one aggregate row per machine.
+            file_path: projectsDir,
+            raw_content: {
+                version,
+                session_count: sessions.size,
+                models: [...models].sort(),
+                model_token_split: modelTokenSplit,
+                window_days: TOKEN_USAGE_RECENCY_DAYS,
+                totals,
+            },
+        },
+    ];
+}
+export { collectClaudeTokenUsage, TOKEN_USAGE_RECENCY_DAYS, TOKEN_USAGE_FILE_TYPE };

package/dist/log_config_files/collection/codex_token_usage_collector.js

@@ -0,0 +1,245 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+/**
+ * Token-usage / session / version / identity aggregator for OpenAI Codex CLI.
+ *
+ * Codex writes one JSONL rollout per session under ~/.codex/sessions/<y>/<m>/<d>/rollout-*.jsonl
+ * (and ~/.codex/archived_sessions/). A `session_meta` line carries `cli_version` + `model_provider`;
+ * `token_count` lines carry a *cumulative* `total_token_usage` ({input,cached_input,output,
+ * reasoning_output}_tokens) — so the session total is its LAST token_count, summed across sessions.
+ *
+ * Identity lives in ~/.codex/auth.json as a JWT (`auth_mode` + an `id_token` whose claims hold
+ * email / name / chatgpt_plan_type / account). We decode the id_token's claims locally and emit
+ * ONLY those (email, name, plan, account) — never the token, access_token, or API key. Configured
+ * model is read from ~/.codex/config.toml. Numbers + identity claims only — no transcript content.
+ *
+ * Bounded by rollout-file mtime recency so a long session history isn't fully re-parsed each run.
+ */
+const TOKEN_USAGE_RECENCY_DAYS = 30;
+const TOKEN_USAGE_FILE_TYPE = 'codex_token_usage';
+function emptyTotals() {
+    return { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 };
+}
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function asObject(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+/** Recursively collect rollout-*.jsonl files under a dir whose mtime is within the window. */
+function recentRolloutFiles(dir, cutoffMs) {
+    const out = [];
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...recentRolloutFiles(full, cutoffMs));
+        }
+        else if (entry.isFile() &&
+            entry.name.startsWith('rollout-') &&
+            entry.name.endsWith('.jsonl')) {
+            try {
+                if (statSync(full).mtimeMs >= cutoffMs)
+                    out.push(full);
+            }
+            catch {
+                /* unreadable — skip */
+            }
+        }
+    }
+    return out;
+}
+/** Decode a JWT's payload claims (no verification — we only read non-secret identity claims). */
+function decodeJwtClaims(jwt) {
+    const parts = jwt.split('.');
+    if (parts.length !== 3)
+        return {};
+    try {
+        let b64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+        b64 += '='.repeat((4 - (b64.length % 4)) % 4);
+        return JSON.parse(Buffer.from(b64, 'base64').toString('utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Identity from ~/.codex/auth.json: auth_mode + id_token claims (email/name/plan/account). */
+function readCodexIdentity(home) {
+    const out = {};
+    let auth;
+    try {
+        auth = JSON.parse(readFileSync(join(home, '.codex', 'auth.json'), 'utf8'));
+    }
+    catch {
+        return out;
+    }
+    if (typeof auth.auth_mode === 'string' && auth.auth_mode)
+        out.auth_mode = auth.auth_mode;
+    const idToken = asObject(auth.tokens).id_token;
+    if (typeof idToken !== 'string' || !idToken)
+        return out;
+    const claims = decodeJwtClaims(idToken);
+    if (typeof claims.email === 'string')
+        out.email = claims.email;
+    if (typeof claims.name === 'string')
+        out.name = claims.name;
+    const openaiAuth = asObject(claims['https://api.openai.com/auth']);
+    if (typeof openaiAuth.chatgpt_plan_type === 'string')
+        out.plan = openaiAuth.chatgpt_plan_type;
+    if (typeof openaiAuth.chatgpt_account_id === 'string') {
+        out.account_id = openaiAuth.chatgpt_account_id;
+    }
+    const orgs = openaiAuth.organizations;
+    if (Array.isArray(orgs) && orgs.length > 0) {
+        const org = asObject(orgs[0]);
+        if (typeof org.id === 'string')
+            out.account_id = out.account_id || org.id;
+        if (typeof org.title === 'string')
+            out.org_name = org.title;
+    }
+    return out;
+}
+/** Configured model from ~/.codex/config.toml (TOML — a simple `model = "..."` line). */
+function readConfiguredModel(home) {
+    try {
+        const toml = readFileSync(join(home, '.codex', 'config.toml'), 'utf8');
+        const m = toml.match(/^\s*model\s*=\s*["']([^"']+)["']/m);
+        return m ? m[1] : '';
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Aggregate Codex token usage / sessions / version across recent rollout transcripts + identity.
+ * Returns a single-element array (one per-machine aggregate) or [] when there is no recent data.
+ */
+function collectCodexTokenUsage(home = homedir()) {
+    const codexDir = join(home, '.codex');
+    const sessionRoots = [join(codexDir, 'sessions'), join(codexDir, 'archived_sessions')];
+    if (!sessionRoots.some((d) => existsSync(d)) && !existsSync(join(codexDir, 'auth.json'))) {
+        return [];
+    }
+    const cutoffMs = Date.now() - TOKEN_USAGE_RECENCY_DAYS * 24 * 60 * 60 * 1000;
+    const files = sessionRoots.flatMap((d) => (existsSync(d) ? recentRolloutFiles(d, cutoffMs) : []));
+    const totals = emptyTotals();
+    const models = new Set();
+    const providers = new Set();
+    const modelTokenSplit = {};
+    const sessions = new Set();
+    // Per-session cumulative usage, keyed by session id (else file path). total_token_usage is
+    // cumulative within a session, so the same session appearing in multiple rollout files
+    // (sessions/ + archived_sessions/) must be deduped — keep the largest snapshot rather than
+    // summing the files, which would double-count.
+    const sessionTotals = new Map();
+    let version = '';
+    let versionAt = '';
+    for (const file of files) {
+        let content;
+        try {
+            content = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        let sessionModel = '';
+        let sessionTotal = null; // last (cumulative) token usage
+        let sessionId = '';
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            const payload = asObject(entry.payload);
+            const ts = typeof entry.timestamp === 'string' ? entry.timestamp : '';
+            if (entry.type === 'session_meta') {
+                if (typeof payload.session_id === 'string')
+                    sessionId = payload.session_id;
+                if (typeof payload.cli_version === 'string' && payload.cli_version && ts >= versionAt) {
+                    version = payload.cli_version;
+                    versionAt = ts;
+                }
+                if (typeof payload.model_provider === 'string' && payload.model_provider) {
+                    providers.add(payload.model_provider);
+                }
+            }
+            // Model id can appear on turn/response lines as payload.model.
+            if (typeof payload.model === 'string' && payload.model) {
+                models.add(payload.model);
+                if (!sessionModel)
+                    sessionModel = payload.model;
+            }
+            if (payload.type === 'token_count') {
+                const usage = asObject(asObject(payload.info).total_token_usage);
+                if (Object.keys(usage).length) {
+                    // Cumulative within the session — keep the latest seen.
+                    sessionTotal = {
+                        input: num(usage.input_tokens),
+                        cached: num(usage.cached_input_tokens),
+                        output: num(usage.output_tokens) + num(usage.reasoning_output_tokens),
+                    };
+                }
+            }
+        }
+        const sessionKey = sessionId || file;
+        sessions.add(sessionKey);
+        if (sessionTotal) {
+            const sum = sessionTotal.input + sessionTotal.cached + sessionTotal.output;
+            const prev = sessionTotals.get(sessionKey);
+            // Keep the largest cumulative snapshot for a session so a duplicate file doesn't double-count.
+            if (!prev || sum > prev.sum) {
+                sessionTotals.set(sessionKey, {
+                    model: sessionModel,
+                    input: sessionTotal.input,
+                    cached: sessionTotal.cached,
+                    output: sessionTotal.output,
+                    sum,
+                });
+            }
+        }
+    }
+    for (const st of sessionTotals.values()) {
+        totals.input_tokens += st.input;
+        totals.cache_read_input_tokens += st.cached;
+        totals.output_tokens += st.output;
+        if (st.model && st.sum > 0) {
+            modelTokenSplit[st.model] = (modelTokenSplit[st.model] ?? 0) + st.sum;
+        }
+    }
+    const identity = readCodexIdentity(home);
+    const configuredModel = readConfiguredModel(home);
+    const sawUsage = files.length > 0;
+    if (!sawUsage && !identity.email)
+        return [];
+    return [
+        {
+            file_type: TOKEN_USAGE_FILE_TYPE,
+            file_path: codexDir, // stable synthetic path → one aggregate row per machine
+            raw_content: {
+                version,
+                session_count: sessions.size,
+                models: [...models].sort(),
+                providers: [...providers].sort(),
+                model_token_split: modelTokenSplit,
+                configured_model: configuredModel,
+                window_days: TOKEN_USAGE_RECENCY_DAYS,
+                totals,
+                ...identity, // auth_mode, email, name, plan, account_id, org_name (claims only)
+            },
+        },
+    ];
+}
+export { collectCodexTokenUsage, TOKEN_USAGE_RECENCY_DAYS, TOKEN_USAGE_FILE_TYPE };

package/dist/log_config_files/collection/config_collector.js

@@ -86,6 +86,12 @@ function readContentByFormat(path, format) {
     // json (default) — fall back to markdown for .md files from agents not yet annotated
     return readJSONFile(path) ?? readMCPConfig(path) ?? (path.endsWith('.md') ? readMarkdownFile(path) : null);
 }
+function isPortableCursorUserSettingsTarget(t) {
+    const p = (t.logicalFilePath ?? t.path).replace(/\\/g, '/').toLowerCase();
+    return (p === 'cursor/user/settings.json' ||
+        p.endsWith('/cursor/user/settings.json') ||
+        p.includes('application support/cursor/user/settings.json'));
+}
 function collectRegularFileEntry(t, enrichByFileType) {
     const format = t.content_format || 'json';
     let content = readContentByFormat(t.path, format);
@@ -120,6 +126,12 @@ function collectRegularFileEntry(t, enrichByFileType) {
             return null;
         raw = filtered;
     }
+    if (t.file_type === 'vscode_settings' &&
+        isPortableCursorUserSettingsTarget(t) &&
+        Object.keys(raw).length === 0) {
+        console.warn(`Skipping empty Cursor User/settings.json upload (path=${t.path}); global ignore would be invisible to the server.`);
+        return null;
+    }
     return { file_type: t.file_type, file_path: t.logicalFilePath ?? t.path, raw_content: raw };
 }
 function collectMetadataEntry(t) {
@@ -215,6 +227,14 @@ export { collectConfigFilesFromPatterns };
 export { collectMcpToolFiles } from './mcp_tool_collector.js';
 export { collectConfigFilesFromInstalledPlugins, collectPluginCacheMcpFiles } from './plugin_collector.js';
 export { collectMcpFromClaudeJsonProjects } from './claude_known_projects_collector.js';
+export { collectClaudeTokenUsage } from './claude_token_usage_collector.js';
+export { collectCopilotTokenUsage } from './copilot_token_usage_collector.js';
+export { collectOpencodeTokenUsage } from './opencode_token_usage_collector.js';
+export { collectCodexTokenUsage } from './codex_token_usage_collector.js';
+export { collectCursorTokenUsage } from './cursor_token_usage_collector.js';
+export { collectHermesTokenUsage } from './hermes_token_usage_collector.js';
+export { collectOpenclawTokenUsage } from './openclaw_token_usage_collector.js';
+export { collectPiTokenUsage } from './pi_token_usage_collector.js';
 export { collectClaudeDesktopExtensionManifests, collectClaudeDesktopExtensionSettingsFiles, enrichClaudeDesktopExtensionsInstallationsUpload, mergeClaudeDesktopExtensionEnableSettings, } from './claude_desktop_extensions_collector.js';
 export { collectCursorProjectWorkspaceMcpConfigs } from './cursor_project_mcp_collector.js';
 export { determineFileTypeFromPath } from './file_type_rules.js';