log-llm-config 1.5.2 → 1.5.9

package/dist/log_config_files/collection/opencode_token_usage_collector.js

@@ -0,0 +1,182 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { resolveSqlite3Binary } from '../runtime/sqlite_binary.js';
+/**
+ * Token-usage / cost / session / version / identity aggregator for OpenCode.
+ *
+ * Unlike Claude/Copilot (JSONL transcripts), OpenCode stores everything in a SQLite DB at
+ * ~/.local/share/opencode/opencode.db. Each assistant row in the `message` table has a JSON
+ * `data` blob carrying `modelID`, `providerID`, `tokens` ({input,output,reasoning,cache:{read,write}})
+ * and `cost`; the `account` table carries the login `email`/`url`; the singleton `account_state`
+ * row carries `active_org_id` (an org identifier — no org *name* exists anywhere in the schema).
+ * We read those via the bundled `sqlite3` binary (same resolver the remediation path uses) and
+ * emit only the aggregated numbers (plus the login email / org id) — never message content. The
+ * DB is opened read-only.
+ *
+ * Bounded by DB-file mtime recency so a stale install isn't re-read every hook run.
+ */
+const TOKEN_USAGE_RECENCY_DAYS = 30;
+const TOKEN_USAGE_FILE_TYPE = 'opencode_token_usage';
+// ASCII record / unit separators: never appear in JSON or emails, so they delimit SELECTed
+// rows/fields unambiguously. In SQL these are char(30) / char(31).
+const ROW_SEP = '\x1e';
+const FIELD_SEP = '\x1f';
+function emptyTotals() {
+    return {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_read_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+    };
+}
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function asObject(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+/** Run a read-only query and return raw stdout, or null when sqlite3/DB is unavailable. */
+function querySqlite(sqlite3, dbPath, sql) {
+    try {
+        return execFileSync(sqlite3, ['-readonly', '-noheader', dbPath], {
+            input: `.timeout 5000\n${sql}\n`,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/** OpenCode CLI version from ~/.config/opencode/package.json (@opencode-ai/plugin pin), best-effort. */
+function readOpencodeVersion(home) {
+    for (const rel of ['.config/opencode/package.json', '.cache/opencode/package.json']) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(home, rel), 'utf8'));
+            const deps = asObject(pkg.dependencies);
+            const v = deps['@opencode-ai/plugin'] ?? deps['opencode'] ?? pkg.version;
+            if (typeof v === 'string' && v)
+                return v.replace(/^[\^~]/, '');
+        }
+        catch {
+            /* missing/unparseable — try next */
+        }
+    }
+    return '';
+}
+/**
+ * Aggregate OpenCode token usage / cost / sessions / models from the SQLite DB.
+ * Returns a single-element array (one per-machine aggregate) or [] when there is no usable DB.
+ */
+function collectOpencodeTokenUsage(home = homedir()) {
+    const dbPath = join(home, '.local', 'share', 'opencode', 'opencode.db');
+    if (!existsSync(dbPath))
+        return [];
+    const cutoffMs = Date.now() - TOKEN_USAGE_RECENCY_DAYS * 24 * 60 * 60 * 1000;
+    try {
+        if (statSync(dbPath).mtimeMs < cutoffMs)
+            return [];
+    }
+    catch {
+        return [];
+    }
+    const sqlite3 = resolveSqlite3Binary();
+    if (!sqlite3)
+        return [];
+    // Window aggregation to the recency horizon (message.time_created is epoch ms) so a touched-but-
+    // -stale DB (VACUUM, backup, one new session) doesn't re-sum all-time history — matches the
+    // 30-day window the Claude/Copilot collectors apply per transcript file. cutoffMs is a numeric
+    // constant we control, so inlining it into the SQL is injection-safe.
+    const cutoffClause = `WHERE time_created >= ${cutoffMs}`;
+    // Assistant message JSON blobs, one per row (char(30)-delimited so embedded newlines in the
+    // JSON don't split rows).
+    const messagesRaw = querySqlite(sqlite3, dbPath, `SELECT data || char(30) FROM message ${cutoffClause};`);
+    if (messagesRaw === null)
+        return [];
+    const totals = emptyTotals();
+    const models = new Set();
+    const providers = new Set();
+    const modelTokenSplit = {};
+    let cost = 0;
+    let sawData = false;
+    for (const blob of messagesRaw.split(ROW_SEP)) {
+        const trimmed = blob.trim();
+        if (!trimmed)
+            continue;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (msg.role !== 'assistant')
+            continue;
+        sawData = true;
+        const model = typeof msg.modelID === 'string' ? msg.modelID : '';
+        if (model)
+            models.add(model);
+        if (typeof msg.providerID === 'string' && msg.providerID)
+            providers.add(msg.providerID);
+        cost += num(msg.cost);
+        const tokens = asObject(msg.tokens);
+        const cache = asObject(tokens.cache);
+        const input = num(tokens.input);
+        const output = num(tokens.output) + num(tokens.reasoning);
+        const cacheRead = num(cache.read);
+        const cacheWrite = num(cache.write);
+        totals.input_tokens += input;
+        totals.output_tokens += output;
+        totals.cache_read_input_tokens += cacheRead;
+        totals.cache_creation_input_tokens += cacheWrite;
+        if (model) {
+            const sum = input + output + cacheRead + cacheWrite;
+            if (sum > 0)
+                modelTokenSplit[model] = (modelTokenSplit[model] ?? 0) + sum;
+        }
+    }
+    // Session count = distinct sessions with activity in the window (the `session` table has no
+    // timestamp, so count distinct session_id from recent messages — consistent with the windowed
+    // token totals above).
+    const sessionCountRaw = querySqlite(sqlite3, dbPath, `SELECT count(DISTINCT session_id) FROM message ${cutoffClause};`);
+    const sessionCount = sessionCountRaw ? num(parseInt(sessionCountRaw.trim(), 10)) : 0;
+    const accountRaw = querySqlite(sqlite3, dbPath, "SELECT COALESCE(email, '') || char(31) || COALESCE(url, '') FROM account ORDER BY time_updated DESC LIMIT 1;");
+    let email = '';
+    let host = '';
+    if (accountRaw && accountRaw.trim()) {
+        const [rawEmail, rawUrl] = accountRaw.trim().split(FIELD_SEP);
+        email = (rawEmail ?? '').trim();
+        host = (rawUrl ?? '')
+            .trim()
+            .replace(/^https?:\/\//, '')
+            .replace(/\/$/, '');
+    }
+    // Singleton row; absent on older installs/schemas without account_state — querySqlite
+    // returns null on "no such table" and orgIdRaw stays empty in that case.
+    const orgIdRaw = querySqlite(sqlite3, dbPath, "SELECT COALESCE(active_org_id, '') FROM account_state LIMIT 1;");
+    const orgId = orgIdRaw ? orgIdRaw.trim() : '';
+    if (!sawData && !email)
+        return [];
+    return [
+        {
+            file_type: TOKEN_USAGE_FILE_TYPE,
+            file_path: dbPath, // stable synthetic path → one aggregate row per machine
+            raw_content: {
+                version: readOpencodeVersion(home),
+                session_count: sessionCount,
+                models: [...models].sort(),
+                providers: [...providers].sort(),
+                model_token_split: modelTokenSplit,
+                cost,
+                email,
+                host,
+                org_id: orgId,
+                window_days: TOKEN_USAGE_RECENCY_DAYS,
+                totals,
+            },
+        },
+    ];
+}
+export { collectOpencodeTokenUsage, TOKEN_USAGE_RECENCY_DAYS, TOKEN_USAGE_FILE_TYPE };

package/dist/log_config_files/collection/pi_token_usage_collector.js

@@ -0,0 +1,203 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+/**
+ * Session / token usage / model / provider aggregator for Pi (earendil-works, pi.dev).
+ *
+ * Pi writes one JSONL transcript per session under
+ * ~/.pi/agent/sessions/<sanitized-cwd>/<timestamp>_<uuid>.jsonl. The first line is a
+ * `type: "session"` header carrying the session `id`; assistant turns are `type: "message"`
+ * lines whose `message.usage` block carries `{input, output, cacheRead, cacheWrite,
+ * totalTokens, reasoning?}` alongside `message.model` / `message.provider`. We aggregate the
+ * *numbers* (and model/provider ids) on the endpoint and emit only those — never
+ * `message.content` (the actual prompt/response text) — so the backend gets token usage,
+ * session count, and models/providers used without ingesting transcript content.
+ *
+ * Configured defaults come from a scoped read of settings.json's `defaultProvider` /
+ * `defaultModel` / `lastChangelogVersion` keys only — never any other key.
+ *
+ * auth.json holds literal per-provider `{type, key}` blobs (`{"anthropic": {"type": ...,
+ * "key": ...}}`), the same risk class as Hermes's/Codex's auth.json. We read only the `type`
+ * field per provider (e.g. `"api_key"`) — never `key`, the actual credential.
+ *
+ * `lastChangelogVersion` (confirmed against a real install: "0.80.3", matching `pi --version`
+ * exactly) is a best-effort CLI version signal, not a guaranteed-current one — it records the
+ * version Pi last showed its changelog for, which in practice tracks the installed version but
+ * could theoretically lag by one release in a narrow upgrade window. The session header's own
+ * `version` field is a JSONL schema version (small int, e.g. `3`), not the CLI version, and is
+ * not used here.
+ *
+ * Bounded by mtime recency so a large session history is not fully re-parsed on every run.
+ */
+const TOKEN_USAGE_RECENCY_DAYS = 30;
+const TOKEN_USAGE_FILE_TYPE = 'pi_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 str(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function asObject(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+/** Recursively collect *.jsonl files under a dir 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;
+}
+/** Scoped read of settings.json's `defaultProvider` / `defaultModel` / `lastChangelogVersion` keys only. */
+function readDefaults(home) {
+    try {
+        const raw = JSON.parse(readFileSync(join(home, '.pi', 'agent', 'settings.json'), 'utf8'));
+        return {
+            provider: str(raw.defaultProvider),
+            model: str(raw.defaultModel),
+            version: str(raw.lastChangelogVersion),
+        };
+    }
+    catch {
+        return { provider: '', model: '', version: '' };
+    }
+}
+/**
+ * Scoped read of auth.json's per-provider `type` field only — never the sibling `key`
+ * credential. Returns a provider -> type map (e.g. `{"anthropic": "api_key"}`).
+ */
+function readAuthTypesByProvider(home) {
+    try {
+        const raw = JSON.parse(readFileSync(join(home, '.pi', 'agent', 'auth.json'), 'utf8'));
+        const out = {};
+        for (const [provider, value] of Object.entries(raw)) {
+            if (!value || typeof value !== 'object')
+                continue;
+            const type = str(value.type);
+            if (type)
+                out[provider] = type;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Aggregate Pi session count / token usage / models / providers across recent session
+ * transcripts. Returns a single-element array (one per-machine aggregate) or [] when there is
+ * no recent data.
+ */
+function collectPiTokenUsage(home = homedir()) {
+    const sessionsDir = join(home, '.pi', 'agent', 'sessions');
+    if (!existsSync(sessionsDir))
+        return [];
+    const cutoffMs = Date.now() - TOKEN_USAGE_RECENCY_DAYS * 24 * 60 * 60 * 1000;
+    const files = recentJsonlFiles(sessionsDir, cutoffMs);
+    if (files.length === 0)
+        return [];
+    const totals = emptyTotals();
+    const sessions = new Set();
+    const models = new Set();
+    const providers = new Set();
+    const modelTokenSplit = {};
+    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;
+            }
+            if (entry.type === 'session') {
+                const sessionId = str(entry.id);
+                if (sessionId)
+                    sessions.add(sessionId);
+                sawData = true;
+                continue;
+            }
+            if (entry.type !== 'message')
+                continue;
+            const message = asObject(entry.message);
+            const usage = asObject(message.usage);
+            if (Object.keys(usage).length === 0)
+                continue;
+            sawData = true;
+            const model = str(message.model);
+            const provider = str(message.provider);
+            if (model)
+                models.add(model);
+            if (provider)
+                providers.add(provider);
+            const input = num(usage.input);
+            // reasoning tokens fold into output_tokens — TokenTotals has no separate reasoning
+            // field (matches Codex's/Hermes's reasoning fold-in convention).
+            const output = num(usage.output) + num(usage.reasoning);
+            const cacheRead = num(usage.cacheRead);
+            totals.input_tokens += input;
+            totals.output_tokens += output;
+            totals.cache_read_input_tokens += cacheRead;
+            const sum = input + output + cacheRead;
+            if (model && sum > 0) {
+                modelTokenSplit[model] = (modelTokenSplit[model] ?? 0) + sum;
+            }
+        }
+    }
+    if (!sawData)
+        return [];
+    const defaults = readDefaults(home);
+    return [
+        {
+            file_type: TOKEN_USAGE_FILE_TYPE,
+            // Stable synthetic path → one aggregate row per machine.
+            file_path: sessionsDir,
+            raw_content: {
+                version: defaults.version,
+                session_count: sessions.size,
+                models: [...models].sort(),
+                providers: [...providers].sort(),
+                model_token_split: modelTokenSplit,
+                configured_model: defaults.model,
+                configured_provider: defaults.provider,
+                window_days: TOKEN_USAGE_RECENCY_DAYS,
+                totals,
+                auth_types_by_provider: readAuthTypesByProvider(home),
+            },
+        },
+    ];
+}
+export { collectPiTokenUsage, TOKEN_USAGE_RECENCY_DAYS, TOKEN_USAGE_FILE_TYPE };

package/dist/log_config_files/paths/path_constants_helpers.js

@@ -27,7 +27,7 @@ export function getInstalledPluginsPath(home, constants) {
     return join(home, rel.replace(/^~\//, ''));
 }
 export function getOptAiSecManagementPath(home, constants) {
-    const rel = requireKey(constants, 'opt_ai_sec_management_under_home', 'opt-ai-sec management path');
+    const rel = requireKey(constants, 'optimuslabs_management_under_home', '.optimuslabs management path');
     return join(home, rel.replace(/^~\//, ''));
 }
 export function getAuthKeyPathFromConstants(home, constants) {

package/dist/log_config_files/runtime/client_event_reporter.js

@@ -13,7 +13,7 @@
 import { existsSync, mkdirSync, appendFileSync, readFileSync, renameSync, unlinkSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { OPT_AI_SEC_MANAGEMENT_REL } from '../../bootstrap_constants.js';
+import { OPTIMUSLABS_MANAGEMENT_REL } from '../../bootstrap_constants.js';
 import { executeBody } from '../../endpoint_client/http_transport.js';
 import { loadEndpointBase } from '../sender/endpoint_config.js';
 import { createSignature } from '../sender/signing.js';
@@ -29,7 +29,7 @@ function bufferPath() {
     const home = process.env.HOME || process.env.USERPROFILE;
     if (!home)
         return null;
-    return path.join(home, OPT_AI_SEC_MANAGEMENT_REL, 'telemetry', BUFFER_BASENAME);
+    return path.join(home, OPTIMUSLABS_MANAGEMENT_REL, 'telemetry', BUFFER_BASENAME);
 }
 /** Keep filename-safe chars only — must match optimus_sanitize_id in optimus-hook-common.sh. */
 function sanitizeId(v) {
@@ -40,7 +40,7 @@ function storyFilePath() {
     const home = process.env.HOME || process.env.USERPROFILE;
     if (!home)
         return null;
-    const telemetryDir = path.join(home, OPT_AI_SEC_MANAGEMENT_REL, 'telemetry');
+    const telemetryDir = path.join(home, OPTIMUSLABS_MANAGEMENT_REL, 'telemetry');
     const session = sanitizeId((process.env.OPTIMUS_SESSION_ID || '').trim());
     if (session) {
         const agent = sanitizeId((process.env.OPTIMUS_HOOK_TYPE || process.env.OPTIMUS_AGENT || 'claude').trim()) || 'claude';
@@ -107,7 +107,7 @@ function hookRunFilePath() {
     const home = process.env.HOME || process.env.USERPROFILE;
     if (!home)
         return null;
-    return path.join(home, OPT_AI_SEC_MANAGEMENT_REL, 'telemetry', 'current_hook_run.id');
+    return path.join(home, OPTIMUSLABS_MANAGEMENT_REL, 'telemetry', 'current_hook_run.id');
 }
 /**
  * hook_run_id: one uuid per shell hook invocation.

package/dist/log_config_files/runtime/compliance_session_log.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, appendFileSync, readFileSync, } from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
-import { OPT_AI_SEC_LOGS_REL, LOG_GROUP_COMPLIANCE } from '../../bootstrap_constants.js';
+import { OPTIMUSLABS_LOGS_REL, LOG_GROUP_COMPLIANCE } from '../../bootstrap_constants.js';
 import { buildLogMetadataBlock } from './log_metadata.js';
 const COMPLIANCE_SUBDIR = LOG_GROUP_COMPLIANCE;
 const TIER_NOOP = 'noop';
@@ -35,7 +35,7 @@ export function isFinalizeComplianceSessionArgv(argv) {
     return argv.includes('--finalize-compliance-session');
 }
 export function getComplianceLogDir() {
-    return path.join(homedir(), OPT_AI_SEC_LOGS_REL, COMPLIANCE_SUBDIR);
+    return path.join(homedir(), OPTIMUSLABS_LOGS_REL, COMPLIANCE_SUBDIR);
 }
 export function getActiveComplianceLogPath() {
     return activeComplianceLogPath;

package/dist/log_config_files/runtime/hook_logger.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, appendFileSync, writeFileSync, statSync, readFileSync } from 'node:fs';
 import path from 'node:path';
-import { OPT_AI_SEC_LOGS_REL, LOG_GROUP_HOOK, LOG_GROUP_COMPLIANCE, } from '../../bootstrap_constants.js';
+import { OPTIMUSLABS_LOGS_REL, LOG_GROUP_HOOK, LOG_GROUP_COMPLIANCE, } from '../../bootstrap_constants.js';
 import { getActiveComplianceLogPath } from './compliance_session_log.js';
 import { buildLogMetadataBlock, formatErrorBlock } from './log_metadata.js';
 const HOOK_LOG_FILENAME = 'hook_log.txt';
@@ -12,13 +12,13 @@ function getHookLogPath() {
     const homeDir = process.env.HOME || process.env.USERPROFILE;
     if (!homeDir)
         return null;
-    return path.join(homeDir, OPT_AI_SEC_LOGS_REL, LOG_GROUP_HOOK, HOOK_LOG_FILENAME);
+    return path.join(homeDir, OPTIMUSLABS_LOGS_REL, LOG_GROUP_HOOK, HOOK_LOG_FILENAME);
 }
 function getComplianceRunnerLogPath() {
     const homeDir = process.env.HOME || process.env.USERPROFILE;
     if (!homeDir)
         return null;
-    return path.join(homeDir, OPT_AI_SEC_LOGS_REL, LOG_GROUP_COMPLIANCE, COMPLIANCE_FALLBACK_TIER, COMPLIANCE_RUNNER_LOG_FILENAME);
+    return path.join(homeDir, OPTIMUSLABS_LOGS_REL, LOG_GROUP_COMPLIANCE, COMPLIANCE_FALLBACK_TIER, COMPLIANCE_RUNNER_LOG_FILENAME);
 }
 /**
  * Append one ISO-timestamped line to the active compliance session log.

package/dist/log_config_files/runtime/log_metadata.js

@@ -7,7 +7,7 @@ import os from 'node:os';
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { OPT_AI_SEC_MANAGEMENT_REL } from '../../bootstrap_constants.js';
+import { OPTIMUSLABS_MANAGEMENT_REL } from '../../bootstrap_constants.js';
 /** This package's name + version as "<name>: <version>", read from its own package.json. */
 function readPackageVersion() {
     try {
@@ -28,7 +28,7 @@ function readBundleVersion() {
     const home = process.env.HOME || process.env.USERPROFILE;
     if (!home)
         return 'unknown';
-    const p = path.join(home, OPT_AI_SEC_MANAGEMENT_REL, 'release', 'bundle-version.json');
+    const p = path.join(home, OPTIMUSLABS_MANAGEMENT_REL, 'release', 'bundle-version.json');
     try {
         if (!existsSync(p))
             return 'unknown';

package/dist/log_config_files/runtime/main_runner.js

@@ -3,7 +3,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 const HOME_DIR = homedir();
 import { getFileCollectionPatterns, FILE_PATH_REGISTRY_FILE_PATTERNS_PATH } from '../../endpoint_client/index.js';
-import { OPT_AI_SEC_LOGS_REL, LOG_GROUP_AUDIT } from '../../bootstrap_constants.js';
+import { OPTIMUSLABS_LOGS_REL, LOG_GROUP_AUDIT } from '../../bootstrap_constants.js';
 import { runSensitivePathsAudit } from '../../log_sensitive_paths_audit.js';
 import { loadEndpointBase, getEndpointSource } from '../sender/endpoint_config.js';
 import { hookLogReplace, hookRunLog, hookLogError, readHookLog } from './hook_logger.js';
@@ -14,7 +14,7 @@ import { ensureAuthentication } from '../auth/auth_flow.js';
 import { readJSONFile, readMarkdownFile } from '../readers/file_readers.js';
 import { isVscdbVirtualPath, tryReadVscdbVirtualFile, summarizeComposerPayloadForDiagnostics, } from '../readers/vscdb_config_builder.js';
 import { persistVscdbComposerContractFromPatternsResponse } from '../readers/vscdb_reader.js';
-import { collectConfigFilesFromPatterns, collectMcpToolFiles, collectConfigFilesFromInstalledPlugins, collectPluginCacheMcpFiles, collectMcpFromClaudeJsonProjects, collectClaudeDesktopExtensionManifests, collectClaudeDesktopExtensionSettingsFiles, enrichClaudeDesktopExtensionsInstallationsUpload, determineFileTypeFromPath, } from '../collection/config_collector.js';
+import { collectConfigFilesFromPatterns, collectMcpToolFiles, collectConfigFilesFromInstalledPlugins, collectPluginCacheMcpFiles, collectMcpFromClaudeJsonProjects, collectClaudeTokenUsage, collectCopilotTokenUsage, collectOpencodeTokenUsage, collectCodexTokenUsage, collectCursorTokenUsage, collectHermesTokenUsage, collectOpenclawTokenUsage, collectPiTokenUsage, collectCoworkDesktopVersion, collectClaudeDesktopExtensionManifests, collectClaudeDesktopExtensionSettingsFiles, enrichClaudeDesktopExtensionsInstallationsUpload, determineFileTypeFromPath, } from '../collection/config_collector.js';
 import { ensureCursorUserSettingsSnapshotInBatch } from '../collection/ensure_cursor_user_settings_snapshot.js';
 import { collectSkillsCliInstalled } from '../collection/skills_cli_collector.js';
 import { collectWorkspaceVscdbs } from '../collection/mcp_tool_collector.js';
@@ -98,6 +98,78 @@ async function collectAllConfigFiles(endpointBase) {
             configFiles.push(entry);
         }
     }
+    hookRunLog(`aggregating Claude token usage from ~/.claude/projects transcripts`);
+    for (const entry of collectClaudeTokenUsage(HOME_DIR)) {
+        const key = `${entry.file_type}\t${entry.file_path}`;
+        if (!existingPaths.has(key)) {
+            existingPaths.add(key);
+            configFiles.push(entry);
+        }
+    }
+    hookRunLog(`aggregating Copilot token usage from ~/.copilot/session-state transcripts`);
+    for (const entry of collectCopilotTokenUsage(HOME_DIR)) {
+        const key = `${entry.file_type}\t${entry.file_path}`;
+        if (!existingPaths.has(key)) {
+            existingPaths.add(key);
+            configFiles.push(entry);
+        }
+    }
+    hookRunLog(`aggregating OpenCode token usage from ~/.local/share/opencode/opencode.db`);
+    for (const entry of collectOpencodeTokenUsage(HOME_DIR)) {
+        const key = `${entry.file_type}\t${entry.file_path}`;
+        if (!existingPaths.has(key)) {
+            existingPaths.add(key);
+            configFiles.push(entry);
+        }
+    }
+    hookRunLog(`aggregating Codex token usage from ~/.codex/sessions rollouts`);
+    for (const entry of collectCodexTokenUsage(HOME_DIR)) {
+        const key = `${entry.file_type}\t${entry.file_path}`;
+        if (!existingPaths.has(key)) {
+            existingPaths.add(key);
+            configFiles.push(entry);
+        }
+    }
+    hookRunLog(`aggregating Cursor token usage from state.vscdb`);
+    for (const entry of collectCursorTokenUsage(HOME_DIR)) {
+        const key = `${entry.file_type}\t${entry.file_path}`;
+        if (!existingPaths.has(key)) {
+            existingPaths.add(key);
+            configFiles.push(entry);
+        }
+    }
+    hookRunLog(`aggregating Hermes token usage from ~/.hermes/state.db`);
+    for (const entry of collectHermesTokenUsage(HOME_DIR)) {
+        const key = `${entry.file_type}\t${entry.file_path}`;
+        if (!existingPaths.has(key)) {
+            existingPaths.add(key);
+            configFiles.push(entry);
+        }
+    }
+    hookRunLog(`aggregating OpenClaw token usage from ~/.openclaw/agents/*/sessions/sessions.json`);
+    for (const entry of collectOpenclawTokenUsage(HOME_DIR)) {
+        const key = `${entry.file_type}\t${entry.file_path}`;
+        if (!existingPaths.has(key)) {
+            existingPaths.add(key);
+            configFiles.push(entry);
+        }
+    }
+    hookRunLog(`aggregating Pi token usage from ~/.pi/agent/sessions transcripts`);
+    for (const entry of collectPiTokenUsage(HOME_DIR)) {
+        const key = `${entry.file_type}\t${entry.file_path}`;
+        if (!existingPaths.has(key)) {
+            existingPaths.add(key);
+            configFiles.push(entry);
+        }
+    }
+    hookRunLog(`reading Claude Desktop app version for Cowork's Agent Profile`);
+    for (const entry of collectCoworkDesktopVersion(HOME_DIR)) {
+        const key = `${entry.file_type}\t${entry.file_path}`;
+        if (!existingPaths.has(key)) {
+            existingPaths.add(key);
+            configFiles.push(entry);
+        }
+    }
     hookRunLog(`merging disk-only Claude Desktop extensions into extensions-installations.json`);
     const diskExtMerge = enrichClaudeDesktopExtensionsInstallationsUpload(configFiles, HOME_DIR);
     hookRunLog(`claude desktop extensions: merged=${diskExtMerge.mergedCount} had_registry_upload=${diskExtMerge.hadRegistryUpload}`);
@@ -135,7 +207,7 @@ async function collectAllConfigFiles(endpointBase) {
 }
 async function addSensitivePathsAudit(endpointBase, configFiles) {
     hookRunLog(`running sensitive paths audit`);
-    const auditOutputDir = join(homedir(), OPT_AI_SEC_LOGS_REL, LOG_GROUP_AUDIT);
+    const auditOutputDir = join(homedir(), OPTIMUSLABS_LOGS_REL, LOG_GROUP_AUDIT);
     try {
         const auditResult = await runSensitivePathsAudit(endpointBase, auditOutputDir, PROJECT_ROOT);
         hookRunLog(`sensitive_paths_audit: ${auditResult.paths.length} path(s)`);

package/dist/log_config_files/runtime/management_storage.js

@@ -1,11 +1,11 @@
 /**
- * Paths and JSON persistence for ~/opt-ai-sec/management:
+ * Paths and JSON persistence for ~/.optimuslabs/management:
  * - remediation_instructions.json (remediations[])
  */
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
-import { OPT_AI_SEC_MANAGEMENT_REL, OPT_AI_SEC_LOGS_REL } from '../../bootstrap_constants.js';
+import { OPTIMUSLABS_MANAGEMENT_REL, OPTIMUSLABS_LOGS_REL } from '../../bootstrap_constants.js';
 export const REMEDIATION_INSTRUCTIONS_BASENAME = 'remediation_instructions.json';
 /** Pending state.vscdb writes applied after Cursor exits (IDE holds the DB locked). */
 export const DEFERRED_VSCDB_APPLY_BASENAME = 'optimus_deferred_vscdb_apply.json';
@@ -51,14 +51,14 @@ export function sanitizeFileCollectionVscdbContract(contract) {
     };
 }
 export function getManagementDir() {
-    return join(homedir(), OPT_AI_SEC_MANAGEMENT_REL);
+    return join(homedir(), OPTIMUSLABS_MANAGEMENT_REL);
 }
-/** Root of the grouped hook log subtree (~/opt-ai-sec/management/logs). */
+/** Root of the grouped hook log subtree (~/.optimuslabs/management/logs). */
 export function getLogsDir() {
-    return join(homedir(), OPT_AI_SEC_LOGS_REL);
+    return join(homedir(), OPTIMUSLABS_LOGS_REL);
 }
 /**
- * Directory for vscdb state/contract files (~/opt-ai-sec/management/vscdb), keeping the
+ * Directory for vscdb state/contract files (~/.optimuslabs/management/vscdb), keeping the
  * several generated vscdb artifacts grouped instead of dangling at the management root.
  * Includes deferred_vscdb_restart.log (detached restart pipeline output).
  */
@@ -66,7 +66,7 @@ export function getVscdbStateDir() {
     return join(getManagementDir(), 'vscdb');
 }
 /**
- * Directory for non-log remediation state (~/opt-ai-sec/management/remediation):
+ * Directory for non-log remediation state (~/.optimuslabs/management/remediation):
  * remediation_instructions.json (what to fix) and remediation_apply_tracking.json
  * (quarantine + verify-failure history that escapes the autofix restart loop).
  * Remediation session logs live under logs/compliance/.
@@ -86,7 +86,7 @@ export function getDeferredVscdbRestartLogPath() {
 export function getFileCollectionVscdbContractPath() {
     return join(getVscdbStateDir(), FILE_COLLECTION_VSCDB_CONTRACT_BASENAME);
 }
-/** Directory for macOS dialog assets/state (~/opt-ai-sec/management/dialog): prefs + cached icon. */
+/** Directory for macOS dialog assets/state (~/.optimuslabs/management/dialog): prefs + cached icon. */
 export function getDialogStateDir() {
     return join(getManagementDir(), 'dialog');
 }