@optimuslabs/harness-map-staging 1.5.16

package/dist/log_config_files/collection/codex_token_usage_collector.js

@@ -0,0 +1,342 @@
+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.
+ *
+ * Routing config also comes from a scoped, section-aware line scan of config.toml (see
+ * readCodexRoutingConfig): top-level `model_provider`/`openai_base_url`/`oss_provider`, and each
+ * `[model_providers.<id>]` table's `base_url`/`wire_api` keys only — never `env_key`,
+ * `experimental_bearer_token`, `auth.*`, or any other key that can carry credential material or
+ * a command string. `[model_providers.amazon-bedrock(.aws)]`'s mere presence is recorded (not its
+ * region/profile values) since selecting that built-in provider id is itself the Bedrock signal.
+ *
+ * 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 '';
+    }
+}
+function emptyCodexRoutingConfig() {
+    return {
+        modelProvider: '',
+        openaiBaseUrl: '',
+        ossProvider: '',
+        hasBedrockConfig: false,
+        customProviders: {},
+    };
+}
+/** Strip quotes from a TOML string value and any trailing inline comment. */
+function stripTomlString(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('"')) {
+        const end = trimmed.indexOf('"', 1);
+        return end !== -1 ? trimmed.slice(1, end) : trimmed.slice(1);
+    }
+    if (trimmed.startsWith("'")) {
+        const end = trimmed.indexOf("'", 1);
+        return end !== -1 ? trimmed.slice(1, end) : trimmed.slice(1);
+    }
+    const commentIdx = trimmed.indexOf('#');
+    return (commentIdx === -1 ? trimmed : trimmed.slice(0, commentIdx)).trim();
+}
+/**
+ * Scoped, section-aware scan of config.toml for routing-relevant keys ONLY:
+ *   - top-level `model_provider` / `openai_base_url` / `oss_provider`
+ *   - each `[model_providers.<id>]` table's `base_url` / `wire_api` keys
+ *   - `[model_providers.amazon-bedrock]` (or its `.aws` sub-table) presence only — never its
+ *     region/profile values
+ * Deliberately not a full TOML parse: every other key in every other section (MCP servers,
+ * hooks, marketplaces, `model_providers.<id>.env_key`/`auth.*`/`experimental_bearer_token`, ...)
+ * is never read, since some of those can carry credential material or shell commands.
+ */
+function readCodexRoutingConfig(home) {
+    const result = emptyCodexRoutingConfig();
+    let text;
+    try {
+        text = readFileSync(join(home, '.codex', 'config.toml'), 'utf8');
+    }
+    catch {
+        return result;
+    }
+    let currentProviderId = '';
+    for (const rawLine of text.split('\n')) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            const section = sectionMatch[1].trim();
+            currentProviderId = '';
+            if (/^model_providers\.amazon-bedrock(\.aws)?$/.test(section)) {
+                result.hasBedrockConfig = true;
+                continue;
+            }
+            const providerMatch = section.match(/^model_providers\.([^.]+)$/);
+            if (providerMatch)
+                currentProviderId = providerMatch[1].replace(/^["']|["']$/g, '');
+            continue;
+        }
+        const kv = line.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*=\s*(.*)$/);
+        if (!kv)
+            continue;
+        const [, key, rawValue] = kv;
+        if (!currentProviderId) {
+            if (key === 'model_provider')
+                result.modelProvider = stripTomlString(rawValue);
+            else if (key === 'openai_base_url')
+                result.openaiBaseUrl = stripTomlString(rawValue);
+            else if (key === 'oss_provider')
+                result.ossProvider = stripTomlString(rawValue);
+            continue;
+        }
+        if (key === 'base_url' || key === 'wire_api') {
+            const entry = result.customProviders[currentProviderId] ?? { baseUrl: '', wireApi: '' };
+            if (key === 'base_url')
+                entry.baseUrl = stripTomlString(rawValue);
+            else
+                entry.wireApi = stripTomlString(rawValue);
+            result.customProviders[currentProviderId] = entry;
+        }
+    }
+    return result;
+}
+/**
+ * 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 routingConfig = readCodexRoutingConfig(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,
+                model_provider: routingConfig.modelProvider,
+                openai_base_url: routingConfig.openaiBaseUrl,
+                oss_provider: routingConfig.ossProvider,
+                has_bedrock_config: routingConfig.hasBedrockConfig,
+                custom_model_providers: routingConfig.customProviders,
+                ...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

@@ -0,0 +1,245 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { readJSONFile, readMCPConfig, readMarkdownFile, readInstalledExtensions } from '../readers/file_readers.js';
+import { getExtensionsCachePath, getExtensionsCacheInstalledSuffix, getVscdbPath } from '../paths/path_constants_helpers.js';
+import { resolvePatternToTargets, normalizePathSkipPrefixes } from '../paths/pattern_resolver.js';
+import { enrichRawFromRecipe } from './enrichment_helpers.js';
+import { applyCoworkSessionWhitelist } from './cowork_session_whitelist.js';
+import { collectDirectoryEntries, collectDirectoryMetadata } from './directory_collector.js';
+import { collectVscdbEntries } from '../readers/vscdb_config_builder.js';
+import { pushDerivedFilesFromRecipe } from './openclaw_helpers.js';
+import { collapseMetadataByFileType } from './metadata_merge.js';
+function withOpencodeEnvPatterns(patterns) {
+    const out = [...patterns];
+    const seen = new Set(out.map((p) => `${p.type}:${p.file_type}:${p.path}`));
+    const add = (pattern) => {
+        const key = `${pattern.type}:${pattern.file_type}:${pattern.path}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push(pattern);
+    };
+    const envConfig = (process.env.OPENCODE_CONFIG || '').trim();
+    if (envConfig) {
+        add({
+            path: envConfig,
+            type: 'file',
+            file_type: 'opencode_mcp',
+            content_format: 'json',
+        });
+    }
+    const envDirRaw = (process.env.OPENCODE_CONFIG_DIR || '').trim();
+    if (!envDirRaw)
+        return out;
+    const envDir = envDirRaw.replace(/[\\/]+$/, '');
+    add({ path: `${envDir}/opencode.json`, type: 'file', file_type: 'opencode_mcp', content_format: 'json' });
+    add({ path: `${envDir}/opencode.jsonc`, type: 'file', file_type: 'opencode_mcp', content_format: 'json' });
+    add({ path: `${envDir}/command-hooks.json`, type: 'file', file_type: 'opencode_command_hooks', content_format: 'json' });
+    add({ path: `${envDir}/command-hooks.jsonc`, type: 'file', file_type: 'opencode_command_hooks', content_format: 'json' });
+    add({ path: `${envDir}/AGENTS.md`, type: 'file', file_type: 'opencode_rule', content_format: 'markdown' });
+    add({ path: `${envDir}/agents/`, type: 'dir', file_type: 'opencode_subagent', content_format: 'markdown', dir_glob: '*.md' });
+    add({ path: `${envDir}/commands/`, type: 'dir', file_type: 'opencode_command', content_format: 'markdown', dir_glob: '*.md' });
+    add({ path: `${envDir}/skills/`, type: 'dir', file_type: 'opencode_skill', content_format: 'markdown', dir_glob: '*.md' });
+    add({ path: `${envDir}/mcp-auth.json`, type: 'file', file_type: 'opencode_mcp_auth', content_format: 'json' });
+    add({ path: `${envDir}/managed.json`, type: 'file', file_type: 'opencode_managed_preference', content_format: 'json' });
+    add({ path: `${envDir}/package.json`, type: 'file', file_type: 'opencode_plugin_manifest', content_format: 'json' });
+    add({ path: `${envDir}/plugins/`, type: 'dir', file_type: 'opencode_plugin', content_format: 'text', dir_glob: '*' });
+    add({ path: `${envDir}/plugin/`, type: 'dir', file_type: 'opencode_plugin', content_format: 'text', dir_glob: '*' });
+    add({ path: `${envDir}/plugins/*/package.json`, type: 'file', file_type: 'opencode_plugin_manifest', content_format: 'json' });
+    add({ path: `${envDir}/plugin/*/package.json`, type: 'file', file_type: 'opencode_plugin_manifest', content_format: 'json' });
+    return out;
+}
+function buildCollectionContext(patterns, projectRoot, home, homeRecurseSkipDirs = [], absolutePathPrefixes = [], mcpToolGlobSpec = null, clientPathConstants = null, pathResolutionSpecs = null) {
+    const seenPaths = new Set();
+    const targets = [];
+    const enrichByFileType = {};
+    const metadataOnlyFileTypes = new Set(patterns.filter((p) => p.collect_style === 'metadata').map((p) => p.file_type));
+    if (metadataOnlyFileTypes.size === 0)
+        metadataOnlyFileTypes.add('claude_log');
+    for (const p of patterns) {
+        if (p.enrich && !enrichByFileType[p.file_type])
+            enrichByFileType[p.file_type] = p.enrich;
+    }
+    for (const p of patterns) {
+        const pathSkipPrefixes = p.path_resolution === 'mcp_tool_glob' ? normalizePathSkipPrefixes(p.path_skip_prefixes) : [];
+        for (const t of resolvePatternToTargets(p.path, p.type, p.file_type, projectRoot, home, pathSkipPrefixes, p.collect_style, p.content_format, p.dir_glob, homeRecurseSkipDirs, p.path_resolution, p.resolve_under_home !== false, absolutePathPrefixes, mcpToolGlobSpec, clientPathConstants, pathResolutionSpecs)) {
+            if (p.raw_key)
+                t.raw_key = p.raw_key;
+            if (p.dir_subdir_filename)
+                t.dir_subdir_filename = p.dir_subdir_filename;
+            if (p.dir_subdir_source)
+                t.dir_subdir_source = p.dir_subdir_source;
+            const key = `${t.path}\t${t.file_type}\t${t.isDirectory ? 'dir' : 'file'}\t${t.dir_glob ?? ''}`;
+            if (!seenPaths.has(key)) {
+                seenPaths.add(key);
+                targets.push(t);
+            }
+        }
+    }
+    return { targets, enrichByFileType, metadataOnlyFileTypes };
+}
+function readContentByFormat(path, format) {
+    if (format === 'markdown' || format === 'text')
+        return readMarkdownFile(path);
+    if (format === 'sqlite_vscdb')
+        return null; // handled upstream by collectVscdbEntries
+    // 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);
+    if (content === null)
+        return null;
+    // For JSON-format files, backend/policy engine expect raw_content to be the parsed object (e.g. permissions.allow)
+    if (format === 'json' && typeof content === 'string') {
+        try {
+            content = JSON.parse(content);
+        }
+        catch {
+            // leave as string if parse fails
+        }
+    }
+    let raw;
+    if (t.raw_key && typeof content === 'string') {
+        raw = { [t.raw_key]: content };
+    }
+    else {
+        raw = typeof content === 'string' ? { content, source: 'file' } : content;
+    }
+    const recipe = enrichByFileType[t.file_type];
+    if (recipe)
+        enrichRawFromRecipe(raw, recipe);
+    // Cowork session metadata: reduce to the PII whitelist (hash identity, drop
+    // server URLs, keep only the activity-signal keys) BEFORE it leaves the
+    // device. Drop the entry entirely if nothing whitelisted survives so raw
+    // session content can never be emitted (e.g. on a JSON parse failure).
+    if (t.file_type === 'cowork_session_metadata') {
+        const filtered = applyCoworkSessionWhitelist(raw);
+        if (filtered === null)
+            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) {
+    try {
+        const stats = statSync(t.path);
+        if (stats.isDirectory?.()) {
+            try {
+                if (readdirSync(t.path).length === 0)
+                    return null;
+            }
+            catch { /* unreadable — assume non-empty, allow */ }
+        }
+        return { file_type: t.file_type, file_path: t.logicalFilePath ?? t.path, raw_content: { filename: t.path, last_modified: stats.mtime.toISOString(), source: 'file_metadata' }, collect_style: 'metadata' };
+    }
+    catch (err) {
+        console.warn(`Error stating ${t.path}:`, err instanceof Error ? err.message : String(err));
+        return null;
+    }
+}
+function handleInstalledExtensions(handledSpecialPaths, configFiles, extensionsCachePath, pathConstants) {
+    if (handledSpecialPaths.has(extensionsCachePath))
+        return;
+    handledSpecialPaths.add(extensionsCachePath);
+    const installed = readInstalledExtensions(extensionsCachePath);
+    const suffix = getExtensionsCacheInstalledSuffix(pathConstants);
+    if (installed.length > 0)
+        configFiles.push({ file_type: 'cursor_extensions', file_path: `${extensionsCachePath}${suffix}`, raw_content: { installedExtensions: installed, source: 'extensions.user.cache', extracted_at: new Date().toISOString() } });
+}
+function collectConfigFilesFromPatterns(patterns, projectRoot, onProgress, options) {
+    // Prefer process.env.HOME so hook invoker (e.g. Cursor) can pass real home when it differs from os.homedir()
+    const home = (process.env.HOME && process.env.HOME.trim()) || homedir();
+    const pathConstants = options?.client_path_constants;
+    if (!pathConstants)
+        throw new Error('client_path_constants required from API response but not provided');
+    const vscdbPath = getVscdbPath(home, pathConstants);
+    const extensionsCachePath = getExtensionsCachePath(home, pathConstants);
+    const extensionsInstalledSuffix = getExtensionsCacheInstalledSuffix(pathConstants);
+    const effectivePatterns = withOpencodeEnvPatterns(patterns);
+    const { targets, enrichByFileType, metadataOnlyFileTypes } = buildCollectionContext(effectivePatterns, projectRoot, home, options?.home_recurse_skip_dirs ?? [], options?.absolute_path_prefixes ?? [], options?.mcp_tool_glob_spec ?? null, pathConstants, options?.path_resolution_specs ?? null);
+    const configFiles = [];
+    const handledSpecialPaths = new Set();
+    const loggedFileTypes = new Set();
+    const vscdbEntrySpecs = options?.vscdbEntrySpecs;
+    const vscdbReadQueries = options?.vscdb_read_queries;
+    const vscdbMergeFromComposerState = options?.vscdb_merge_from_composer_state;
+    for (const t of targets) {
+        if (onProgress && !loggedFileTypes.has(t.file_type)) {
+            loggedFileTypes.add(t.file_type);
+            onProgress(`scanning file_type=${t.file_type}`);
+        }
+        if (t.isDirectory) {
+            if (metadataOnlyFileTypes.has(t.file_type) || t.collect_style === 'metadata') {
+                const entry = collectDirectoryMetadata(t);
+                if (entry)
+                    configFiles.push(entry);
+            }
+            else {
+                configFiles.push(...collectDirectoryEntries(t));
+            }
+            continue;
+        }
+        if (extensionsInstalledSuffix && t.path.includes(extensionsInstalledSuffix)) {
+            handleInstalledExtensions(handledSpecialPaths, configFiles, extensionsCachePath, pathConstants);
+            continue;
+        }
+        if (t.path === vscdbPath || t.path.startsWith(vscdbPath + '#')) {
+            if (!handledSpecialPaths.has(vscdbPath)) {
+                handledSpecialPaths.add(vscdbPath);
+                configFiles.push(...collectVscdbEntries(vscdbPath, vscdbEntrySpecs, vscdbReadQueries, vscdbMergeFromComposerState));
+            }
+            continue;
+        }
+        if (!existsSync(t.path))
+            continue;
+        if ((metadataOnlyFileTypes.has(t.file_type) || t.collect_style === 'metadata') && !t.isDirectory) {
+            const entry = collectMetadataEntry(t);
+            if (entry)
+                configFiles.push(entry);
+            continue;
+        }
+        const entry = collectRegularFileEntry(t, enrichByFileType);
+        if (entry) {
+            configFiles.push(entry);
+            const recipe = enrichByFileType[t.file_type];
+            if (recipe?.derived_files?.length)
+                pushDerivedFilesFromRecipe(entry.raw_content, configFiles, recipe);
+        }
+    }
+    return collapseMetadataByFileType(configFiles);
+}
+// ─── Re-exports (barrel for public API) ──────────────────────────────────────
+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 { collectCoworkDesktopVersion } from './cowork_desktop_version_collector.js';
+export { collectGrokCliVersion } from './grok_cli_version_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';
+export { enrichRawFromRecipe } from './enrichment_helpers.js';
+export { pushDerivedFilesFromRecipe } from './openclaw_helpers.js';
+export { getByPath } from './enrichment_helpers.js';