forkit-ai-footprints 0.2.0 → 0.2.4

package/dist/activity-view-model.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeActivitySegments = mergeActivitySegments;
+exports.normalizeActivitySegments = normalizeActivitySegments;
+exports.calculateSystemContributions = calculateSystemContributions;
+exports.buildResourceHistoryView = buildResourceHistoryView;
+exports.aggregateCurrentAiResources = aggregateCurrentAiResources;
+exports.availableLocalDateKeys = availableLocalDateKeys;
+exports.formatObservationDateRange = formatObservationDateRange;
+exports.selectedTimeRange = selectedTimeRange;
+exports.resolveSelectedSystemSignature = resolveSelectedSystemSignature;
+exports.insightEvidenceTarget = insightEvidenceTarget;
+exports.buildActivityExplorerViewModel = buildActivityExplorerViewModel;
+function finiteTimestamp(value) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function sameStrings(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function canMerge(left, right, toleranceMs) {
+    return left.state === right.state
+        && left.valid === right.valid
+        && left.continuity_id === right.continuity_id
+        && left.excluded_reason === right.excluded_reason
+        && sameStrings(left.system_signatures, right.system_signatures)
+        && right.start_ms - left.end_ms <= toleranceMs;
+}
+function mergeActivitySegments(segments, toleranceMs) {
+    const merged = [];
+    for (const segment of segments) {
+        const previous = merged.at(-1);
+        if (previous && canMerge(previous, segment, toleranceMs))
+            previous.end_ms = Math.max(previous.end_ms, segment.end_ms);
+        else
+            merged.push({ ...segment, system_signatures: [...segment.system_signatures] });
+    }
+    return merged;
+}
+function normalizeActivitySegments(timeline, sampleIntervalMs) {
+    const safeInterval = Math.max(1, sampleIntervalMs);
+    const source = timeline.flatMap((segment) => {
+        const start = finiteTimestamp(segment.started_at);
+        const end = finiteTimestamp(segment.ended_at);
+        if (start === null || end === null || end < start)
+            return [];
+        return [{
+                start_ms: start,
+                end_ms: end,
+                state: segment.state === 'working-now' ? 'active' : 'idle',
+                valid: true,
+                system_signatures: [...new Set(segment.product_signatures)].sort(),
+                observation_id: segment.observation_id ?? null,
+                continuity_id: segment.continuity_id ?? segment.observation_id ?? null,
+                excluded_reason: null,
+            }];
+    }).sort((left, right) => left.start_ms - right.start_ms || left.end_ms - right.end_ms);
+    const withExcluded = [];
+    for (const segment of source) {
+        const previous = withExcluded.at(-1);
+        if (previous) {
+            const gap = segment.start_ms - previous.end_ms;
+            const sessionChanged = previous.observation_id !== null
+                && segment.observation_id !== null
+                && previous.observation_id !== segment.observation_id;
+            if (gap > safeInterval * 3 || (sessionChanged && gap > safeInterval * 1.5)) {
+                withExcluded.push({
+                    start_ms: previous.end_ms,
+                    end_ms: segment.start_ms,
+                    state: 'excluded',
+                    valid: false,
+                    system_signatures: [],
+                    observation_id: null,
+                    continuity_id: null,
+                    excluded_reason: null,
+                });
+            }
+        }
+        withExcluded.push(segment);
+    }
+    const merged = mergeActivitySegments(withExcluded, safeInterval * 1.5);
+    const activeBlocks = [];
+    merged.forEach((segment, index) => {
+        if (segment.state !== 'active')
+            return;
+        const previous = activeBlocks.at(-1);
+        const continues = previous
+            && previous.continuity_id === segment.continuity_id
+            && segment.start_ms - previous.end_ms <= safeInterval * 3
+            && merged.slice(previous.indexes.at(-1) + 1, index).every((between) => between.state === 'active');
+        if (continues) {
+            previous.end_ms = Math.max(previous.end_ms, segment.end_ms);
+            previous.indexes.push(index);
+        }
+        else
+            activeBlocks.push({ start_ms: segment.start_ms, end_ms: segment.end_ms, indexes: [index], continuity_id: segment.continuity_id });
+    });
+    const longestBlock = activeBlocks.sort((left, right) => (right.end_ms - right.start_ms) - (left.end_ms - left.start_ms))[0] ?? null;
+    const longestIndexes = new Set(longestBlock?.indexes ?? []);
+    const activeBlockByIndex = new Map(activeBlocks.flatMap((block, blockIndex) => block.indexes.map((index) => [index, blockIndex])));
+    return merged.map((segment, index) => ({
+        id: `segment-${index}-${segment.start_ms}`,
+        ...segment,
+        duration_seconds: Math.max(0, segment.end_ms - segment.start_ms) / 1000,
+        is_longest_active: longestIndexes.has(index),
+        active_block_id: activeBlockByIndex.get(index) ?? null,
+    }));
+}
+function calculateSystemContributions(products) {
+    const hasEmbeddedCodex = products.some((product) => product.signature === 'chatgpt-codex');
+    const active = products
+        .filter((product) => !(hasEmbeddedCodex && product.signature === 'chatgpt'))
+        .filter((product) => Number.isFinite(product.active_seconds) && product.active_seconds > 0)
+        .map((product) => ({
+        signature: product.signature,
+        name: product.name,
+        kind: product.kind,
+        active_seconds: Math.max(0, product.active_seconds),
+    }));
+    const total = active.reduce((sum, product) => sum + product.active_seconds, 0);
+    return active
+        .map((product) => ({ ...product, share: total > 0 ? product.active_seconds / total : 0 }))
+        .sort((left, right) => right.active_seconds - left.active_seconds || left.name.localeCompare(right.name));
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function weightedAverage(values, value, weight) {
+    let total = 0;
+    let measured = 0;
+    for (const item of values) {
+        const next = value(item);
+        if (next === null)
+            continue;
+        const nextWeight = Math.max(0, weight(item));
+        if (nextWeight <= 0)
+            continue;
+        total += next * nextWeight;
+        measured += nextWeight;
+    }
+    return measured > 0 ? total / measured : null;
+}
+function rounded(value, digits = 1) {
+    const factor = 10 ** digits;
+    return Math.round(value * factor) / factor;
+}
+function buildResourceHistoryView(history = []) {
+    const buckets = history.flatMap((bucket) => {
+        const start = finiteTimestamp(bucket.started_at);
+        const end = finiteTimestamp(bucket.ended_at);
+        if (start === null || end === null || end < start)
+            return [];
+        return [{
+                start_ms: start,
+                end_ms: end,
+                system_signature: bucket.system_signature,
+                system_name: bucket.system_name,
+                kind: bucket.kind,
+                observed_seconds: Math.max(0, Number(bucket.observed_seconds) || 0),
+                active_seconds: Math.max(0, Number(bucket.active_seconds) || 0),
+                avg_cpu_percent: finiteNumber(bucket.avg_cpu_percent),
+                peak_cpu_percent: finiteNumber(bucket.peak_cpu_percent),
+                avg_memory_bytes: finiteNumber(bucket.avg_memory_bytes),
+                peak_memory_bytes: finiteNumber(bucket.peak_memory_bytes),
+                peak_process_count: Math.max(0, Math.trunc(Number(bucket.peak_process_count) || 0)),
+                sample_count: Math.max(0, Math.trunc(Number(bucket.sample_count) || 0)),
+            }];
+    }).sort((left, right) => left.start_ms - right.start_ms || left.system_name.localeCompare(right.system_name));
+    const bySystem = new Map();
+    for (const bucket of buckets)
+        bySystem.set(bucket.system_signature, [...(bySystem.get(bucket.system_signature) ?? []), bucket]);
+    const systems = [...bySystem.entries()].map(([signature, entries]) => ({
+        signature,
+        name: entries.at(-1)?.system_name ?? signature,
+        kind: entries.at(-1)?.kind ?? 'unknown',
+        observed_seconds: rounded(entries.reduce((sum, bucket) => sum + bucket.observed_seconds, 0)),
+        active_seconds: rounded(entries.reduce((sum, bucket) => sum + bucket.active_seconds, 0)),
+        avg_cpu_percent: (() => {
+            const value = weightedAverage(entries, (bucket) => bucket.avg_cpu_percent, (bucket) => bucket.observed_seconds);
+            return value === null ? null : rounded(value);
+        })(),
+        peak_cpu_percent: entries.reduce((maximum, bucket) => {
+            const value = finiteNumber(bucket.peak_cpu_percent);
+            return value === null ? maximum : maximum === null ? value : Math.max(maximum, value);
+        }, null),
+        avg_memory_bytes: (() => {
+            const value = weightedAverage(entries, (bucket) => bucket.avg_memory_bytes, (bucket) => bucket.observed_seconds);
+            return value === null ? null : Math.round(value);
+        })(),
+        peak_memory_bytes: entries.reduce((maximum, bucket) => {
+            const value = finiteNumber(bucket.peak_memory_bytes);
+            return value === null ? maximum : maximum === null ? value : Math.max(maximum, value);
+        }, null),
+        peak_process_count: entries.reduce((maximum, bucket) => Math.max(maximum, bucket.peak_process_count), 0),
+        sample_count: entries.reduce((sum, bucket) => sum + bucket.sample_count, 0),
+    })).sort((left, right) => right.active_seconds - left.active_seconds || right.observed_seconds - left.observed_seconds || left.name.localeCompare(right.name));
+    return { buckets, systems };
+}
+function aggregateCurrentAiResources(products) {
+    const cpu = products.map((product) => finiteNumber(product.cpu_percent)).filter((value) => value !== null);
+    const memory = products.map((product) => finiteNumber(product.memory_bytes)).filter((value) => value !== null);
+    return {
+        cpu_percent: cpu.length ? cpu.reduce((sum, value) => sum + Math.max(0, value), 0) : null,
+        memory_bytes: memory.length ? memory.reduce((sum, value) => sum + Math.max(0, value), 0) : null,
+        process_count: products.reduce((sum, product) => sum + Math.max(0, Math.trunc(product.process_count || 0)), 0),
+        contributing_system_count: products.filter((product) => finiteNumber(product.cpu_percent) !== null || finiteNumber(product.memory_bytes) !== null).length,
+        measurement: 'current-detected-process-trees',
+    };
+}
+function dateKeyFormatter(timeZone) {
+    return new Intl.DateTimeFormat('en-CA', {
+        timeZone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+    });
+}
+function dateKeyParts(timestampMs, formatter) {
+    const parts = Object.fromEntries(formatter.formatToParts(new Date(timestampMs)).map((part) => [part.type, part.value]));
+    return `${parts.year}-${parts.month}-${parts.day}`;
+}
+function availableLocalDateKeys(segments, timeZone) {
+    const keys = new Set();
+    const formatter = dateKeyFormatter(timeZone);
+    for (const segment of segments) {
+        if (segment.state === 'excluded')
+            continue;
+        const end = Math.max(segment.start_ms, segment.end_ms - 1);
+        for (let cursor = segment.start_ms; cursor < end; cursor += 6 * 60 * 60 * 1000)
+            keys.add(dateKeyParts(cursor, formatter));
+        keys.add(dateKeyParts(end, formatter));
+    }
+    return [...keys].sort();
+}
+function formatObservationDateRange(extent, locale, timeZone) {
+    if (!extent)
+        return null;
+    const keyFormatter = dateKeyFormatter(timeZone);
+    const startKey = dateKeyParts(extent.start_ms, keyFormatter);
+    const endKey = dateKeyParts(Math.max(extent.start_ms, extent.end_ms - 1), keyFormatter);
+    const formatter = new Intl.DateTimeFormat(locale, {
+        timeZone,
+        day: 'numeric',
+        month: 'short',
+        year: 'numeric',
+    });
+    const start = formatter.format(new Date(extent.start_ms));
+    if (startKey === endKey)
+        return start;
+    return `${start} – ${formatter.format(new Date(Math.max(extent.start_ms, extent.end_ms - 1)))}`;
+}
+function systemActivitySummaries(products, segments, contributions, sampleIntervalMs, resourceHistory) {
+    const contributionMap = new Map(contributions.map((item) => [item.signature, item]));
+    const resourceMap = new Map(resourceHistory.systems.map((item) => [item.signature, item]));
+    return products
+        .filter((product) => !(product.signature === 'chatgpt' && products.some((candidate) => candidate.signature === 'chatgpt-codex')))
+        .map((product) => {
+        const active = segments.filter((segment) => segment.state === 'active' && segment.system_signatures.includes(product.signature));
+        const periods = [];
+        for (const segment of active) {
+            const previous = periods.at(-1);
+            if (previous
+                && previous.observation_id === segment.observation_id
+                && segment.start_ms - previous.end_ms <= Math.max(1_500, sampleIntervalMs * 3)) {
+                previous.end_ms = Math.max(previous.end_ms, segment.end_ms);
+            }
+            else
+                periods.push({ start_ms: segment.start_ms, end_ms: segment.end_ms, observation_id: segment.observation_id });
+        }
+        const contribution = contributionMap.get(product.signature) ?? {
+            signature: product.signature,
+            name: product.name,
+            kind: product.kind,
+            active_seconds: Math.max(0, product.active_seconds || 0),
+            share: 0,
+        };
+        const resources = resourceMap.get(product.signature);
+        return {
+            ...contribution,
+            state: product.state,
+            period_count: periods.length,
+            longest_active_seconds: periods.reduce((maximum, period) => Math.max(maximum, (period.end_ms - period.start_ms) / 1000), 0),
+            first_observed_ms: periods[0]?.start_ms ?? null,
+            last_observed_ms: periods.at(-1)?.end_ms ?? null,
+            current_cpu_percent: finiteNumber(product.cpu_percent),
+            current_memory_bytes: finiteNumber(product.memory_bytes),
+            current_process_count: Math.max(0, Math.trunc(product.process_count || 0)),
+            resource_observed_seconds: resources?.observed_seconds ?? 0,
+            resource_active_seconds: resources?.active_seconds ?? 0,
+            avg_cpu_percent: resources?.avg_cpu_percent ?? null,
+            peak_cpu_percent: resources?.peak_cpu_percent ?? null,
+            avg_memory_bytes: resources?.avg_memory_bytes ?? null,
+            peak_memory_bytes: resources?.peak_memory_bytes ?? null,
+            peak_process_count: resources?.peak_process_count ?? 0,
+            resource_sample_count: resources?.sample_count ?? 0,
+        };
+    })
+        .sort((left, right) => right.active_seconds - left.active_seconds || left.name.localeCompare(right.name));
+}
+function selectedTimeRange(segment) {
+    return { start_ms: segment.start_ms, end_ms: segment.end_ms, duration_seconds: segment.duration_seconds };
+}
+function resolveSelectedSystemSignature(view, selectedSignature) {
+    return selectedSignature && view.systems.some((system) => system.signature === selectedSignature)
+        ? selectedSignature
+        : null;
+}
+function insightEvidenceTarget(kind, segments, contributions) {
+    if (kind === 'longest-block') {
+        const longest = segments.filter((segment) => segment.is_longest_active);
+        if (longest.length)
+            return { type: 'range', start_ms: longest[0].start_ms, end_ms: longest.at(-1).end_ms };
+    }
+    if (kind === 'workflow' || kind === 'hosted-local') {
+        const dominant = contributions[0];
+        if (dominant)
+            return { type: 'system', signature: dominant.signature };
+    }
+    return { type: 'observation' };
+}
+function buildActivityExplorerViewModel(snapshot, insights = []) {
+    const segments = normalizeActivitySegments(snapshot.timeline, snapshot.sample_interval_ms);
+    const resourceHistory = buildResourceHistoryView(snapshot.resource_history ?? []);
+    const contributions = calculateSystemContributions(snapshot.products);
+    const activeSegments = segments.filter((segment) => segment.state === 'active');
+    const activeBlockIds = new Set(activeSegments.flatMap((segment) => segment.active_block_id === null ? [] : [segment.active_block_id]));
+    const longestSegments = activeSegments.filter((segment) => segment.is_longest_active);
+    const longestRange = longestSegments.length
+        ? { start_ms: longestSegments[0].start_ms, end_ms: longestSegments.at(-1).end_ms }
+        : null;
+    const excludedSeconds = segments
+        .filter((segment) => segment.state === 'excluded')
+        .reduce((sum, segment) => sum + segment.duration_seconds, 0);
+    const extent = segments.length > 0
+        ? { start_ms: segments[0].start_ms, end_ms: segments.at(-1).end_ms }
+        : null;
+    const systems = systemActivitySummaries(snapshot.products, segments, contributions, snapshot.sample_interval_ms, resourceHistory);
+    return {
+        segments,
+        contributions,
+        insights: insights.map((insight) => ({
+            ...insight,
+            evidence: insightEvidenceTarget(insight.kind, segments, contributions),
+        })),
+        extent,
+        active_block_count: activeBlockIds.size,
+        longest_active_seconds: longestRange ? Math.max(0, longestRange.end_ms - longestRange.start_ms) / 1000 : 0,
+        longest_active_range: longestRange,
+        idle_seconds: Math.max(0, snapshot.observed_seconds - snapshot.active_seconds),
+        excluded_seconds: excludedSeconds,
+        simultaneous_systems_max: activeSegments.reduce((maximum, segment) => Math.max(maximum, segment.system_signatures.length), 0),
+        active_tool_count: systems.filter((system) => system.active_seconds > 0 || system.state === 'working-now').length,
+        observation_ids: [...new Set(segments.flatMap((segment) => segment.observation_id === null ? [] : [segment.observation_id]))].sort((left, right) => left - right),
+        continuity_ids: [...new Set(segments.flatMap((segment) => segment.continuity_id === null ? [] : [segment.continuity_id]))].sort((left, right) => left - right),
+        available_date_keys: availableLocalDateKeys(segments),
+        systems,
+        current_resources: aggregateCurrentAiResources(snapshot.products),
+        resource_history: resourceHistory,
+        resource_history_state: resourceHistory.buckets.length > 0
+            ? 'retained-local-buckets'
+            : snapshot.lifecycle === 'monitoring' ? 'collecting' : 'not-retained',
+    };
+}
+//# sourceMappingURL=activity-view-model.js.map

package/dist/agents.d.ts

@@ -9,7 +9,9 @@ export interface ClassifiedAgentProcess {
     relationship: 'direct' | 'descendant';
     cpu_percent: number | null;
     memory_percent: number | null;
+    memory_bytes: number | null;
     cpu_time_ms: number | null;
+    activity_signal?: boolean;
 }
 /**
  * Builds private process-tree evidence for the activity monitor. PIDs and raw

package/dist/agents.js

@@ -13,6 +13,10 @@ const node_util_1 = require("node:util");
 const hash_1 = require("./hash");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const SIGNATURES = [
+    { signature: 'chatgpt', name: 'ChatGPT', kind: 'ai-app', terms: ['chatgpt'], executables: ['chatgpt'] },
+    { signature: 'jan', name: 'Jan', kind: 'ai-app', terms: ['jan'], executables: ['jan'] },
+    { signature: 'lm-studio', name: 'LM Studio', kind: 'ai-app', terms: ['lm-studio', 'lmstudio', 'lm studio'], executables: ['lm-studio', 'lmstudio', 'lm studio'] },
+    { signature: 'open-webui', name: 'Open WebUI', kind: 'ai-app', terms: ['open-webui', 'open_webui'], executables: ['open-webui', 'open_webui'] },
     { signature: 'codex', name: 'Codex', kind: 'coding-agent', terms: ['codex'], executables: ['codex'] },
     { signature: 'claude', name: 'Claude Code', kind: 'coding-agent', terms: ['claude', 'claude-code'], executables: ['claude'] },
     { signature: 'aider', name: 'Aider', kind: 'coding-agent', terms: ['aider'], executables: ['aider'] },
@@ -35,6 +39,13 @@ const SIGNATURES = [
     { signature: 'pydantic-ai', name: 'PydanticAI', kind: 'agent-framework', terms: ['pydantic-ai', 'pydantic_ai'], executables: ['pydantic-ai', 'pydantic_ai'] },
     { signature: 'smolagents', name: 'smolagents', kind: 'agent-framework', terms: ['smolagents'], executables: ['smolagents'] },
 ];
+const CHATGPT_CODEX_SIGNATURE = {
+    signature: 'chatgpt-codex',
+    name: 'ChatGPT · Codex',
+    kind: 'ai-app',
+    terms: ['chatgpt-codex'],
+    executables: ['chatgpt', 'codex'],
+};
 function basename(value) {
     const normalized = String(value || '').replaceAll('\\', '/');
     return node_path_1.default.posix.basename(normalized).toLowerCase().replace(/\.exe$/i, '');
@@ -44,6 +55,15 @@ function commandParts(value) {
         .match(/"[^"]*"|'[^']*'|\S+/g)
         ?.map((part) => part.replace(/^(?:"|')|(?:"|')$/g, '')) ?? [];
 }
+function macosAppExecutableName(command) {
+    const marker = '.app/Contents/MacOS/';
+    const markerIndex = command.indexOf(marker);
+    if (markerIndex < 0)
+        return null;
+    const tail = command.slice(markerIndex + marker.length);
+    const executable = tail.split(/\s--/)[0]?.trim();
+    return executable ? basename(executable) : null;
+}
 function moduleName(parts) {
     const moduleFlag = parts.findIndex((part) => part === '-m');
     if (moduleFlag < 0)
@@ -77,12 +97,36 @@ function nodeBinName(parts) {
         return null;
     return basename(script);
 }
+function isNonAiSupportProcess(processName, executable, command) {
+    const supportText = `${processName} ${executable} ${command}`.toLowerCase();
+    return supportText.includes('browser_crashpad_handler')
+        || supportText.includes('crashpad_handler')
+        || processName === 'autoupdate'
+        || processName === 'updater'
+        || executable === 'autoupdate'
+        || executable === 'updater';
+}
+function isPassiveAppHelperProcess(entry) {
+    const processText = `${entry.name ?? ''} ${entry.cmd ?? ''}`.toLowerCase();
+    return processText.includes('codex (renderer)')
+        || processText.includes('codex (service)')
+        || processText.includes('--type=renderer')
+        || processText.includes('--type=utility')
+        || processText.includes('--type=gpu-process')
+        || processText.includes('browser_crashpad_handler')
+        || processText.includes('crashpad_handler')
+        || processText.includes('/sparkle.framework/')
+        || /\bautoupdate\b/.test(processText)
+        || /\bupdater\b/.test(processText);
+}
 function classifyProcess(entry) {
     const processName = basename(entry.name ?? '');
     const command = String(entry.cmd ?? '');
     const parts = commandParts(command);
     const firstCommandToken = parts[0] ?? '';
-    const executable = basename(firstCommandToken || processName) || 'unknown';
+    const executable = macosAppExecutableName(command) ?? (basename(firstCommandToken || processName) || 'unknown');
+    if (isNonAiSupportProcess(processName, executable, command))
+        return null;
     const invokedModule = moduleName(parts);
     const invokedPackage = packageRunnerName(parts) ?? nodeBinName(parts);
     for (const signature of SIGNATURES) {
@@ -125,6 +169,57 @@ function descendantsOf(processes, rootPid) {
     }
     return excluded;
 }
+function nearestDirectAncestor(byPid, direct, start, signature) {
+    const visited = new Set();
+    let parentPid = start.ppid;
+    for (let depth = 0; parentPid !== undefined && parentPid > 0 && depth < 24; depth += 1) {
+        if (visited.has(parentPid))
+            break;
+        visited.add(parentPid);
+        const owner = direct.get(parentPid);
+        if (owner?.signature.signature === signature)
+            return parentPid;
+        parentPid = byPid.get(parentPid)?.ppid;
+    }
+    return null;
+}
+function asEmbeddedChatGptCodex(evidence) {
+    return {
+        ...evidence,
+        signature: CHATGPT_CODEX_SIGNATURE,
+        confidence: 'high',
+        reason: 'embedded_chatgpt_codex_process_tree',
+        evidenceHash: (0, hash_1.sha256)(`${CHATGPT_CODEX_SIGNATURE.signature}:${evidence.executable}:${evidence.reason}`),
+    };
+}
+function collapseEmbeddedOpenAiAppStack(processes, direct) {
+    const byPid = new Map(processes.map((entry) => [entry.pid, entry]));
+    const chatGptRootsWithCodex = new Set();
+    const embeddedCodexPids = new Set();
+    for (const entry of processes) {
+        const owner = direct.get(entry.pid);
+        if (owner?.signature.signature !== 'codex')
+            continue;
+        const chatGptRoot = nearestDirectAncestor(byPid, direct, entry, 'chatgpt');
+        if (chatGptRoot === null)
+            continue;
+        chatGptRootsWithCodex.add(chatGptRoot);
+        embeddedCodexPids.add(entry.pid);
+    }
+    if (chatGptRootsWithCodex.size === 0)
+        return direct;
+    const collapsed = new Map();
+    for (const [pid, evidence] of direct) {
+        if ((evidence.signature.signature === 'chatgpt' && chatGptRootsWithCodex.has(pid))
+            || (evidence.signature.signature === 'codex' && embeddedCodexPids.has(pid))) {
+            collapsed.set(pid, asEmbeddedChatGptCodex(evidence));
+        }
+        else {
+            collapsed.set(pid, evidence);
+        }
+    }
+    return collapsed;
+}
 /**
  * Builds private process-tree evidence for the activity monitor. PIDs and raw
  * commands remain internal and are deliberately absent from public reports.
@@ -140,11 +235,12 @@ function classifyAgentProcessTrees(processes, excludedRootPid = process.pid) {
         if (evidence)
             direct.set(entry.pid, evidence);
     }
+    const collapsedDirect = collapseEmbeddedOpenAiAppStack(processes, direct);
     const result = [];
     for (const entry of processes) {
         if (excluded.has(entry.pid))
             continue;
-        let owner = direct.get(entry.pid) ?? null;
+        let owner = collapsedDirect.get(entry.pid) ?? null;
         let relationship = 'direct';
         if (!owner) {
             const visited = new Set();
@@ -153,7 +249,7 @@ function classifyAgentProcessTrees(processes, excludedRootPid = process.pid) {
                 if (visited.has(parentPid) || excluded.has(parentPid))
                     break;
                 visited.add(parentPid);
-                owner = direct.get(parentPid) ?? null;
+                owner = collapsedDirect.get(parentPid) ?? null;
                 if (owner) {
                     relationship = 'descendant';
                     break;
@@ -173,7 +269,9 @@ function classifyAgentProcessTrees(processes, excludedRootPid = process.pid) {
             relationship,
             cpu_percent: Number.isFinite(entry.cpu_percent) ? Math.max(0, Number(entry.cpu_percent)) : null,
             memory_percent: Number.isFinite(entry.memory_percent) ? Math.max(0, Number(entry.memory_percent)) : null,
+            memory_bytes: Number.isFinite(entry.rss_bytes) ? Math.max(0, Number(entry.rss_bytes)) : null,
             cpu_time_ms: Number.isFinite(entry.cpu_time_ms) ? Math.max(0, Number(entry.cpu_time_ms)) : null,
+            activity_signal: !isPassiveAppHelperProcess(entry),
         });
     }
     return result.sort((left, right) => left.signature.localeCompare(right.signature) || left.pid - right.pid);
@@ -220,11 +318,15 @@ function confidenceRank(confidence) {
     return confidence === 'high' ? 3 : confidence === 'medium' ? 2 : 1;
 }
 function detectAgentProducts(processes) {
-    const grouped = new Map();
+    const direct = new Map();
     for (const process of processes) {
         const evidence = classifyProcess(process);
-        if (!evidence)
-            continue;
+        if (evidence)
+            direct.set(process.pid, evidence);
+    }
+    const collapsedDirect = collapseEmbeddedOpenAiAppStack(processes, direct);
+    const grouped = new Map();
+    for (const evidence of collapsedDirect.values()) {
         grouped.set(evidence.signature.signature, [
             ...(grouped.get(evidence.signature.signature) ?? []),
             evidence,