forkit-ai-footprints 0.2.0

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/localization.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UI_COPY = void 0;
+exports.normalizeLocale = normalizeLocale;
+exports.uiText = uiText;
+exports.UI_COPY = {
+    en: {
+        localDevice: 'Local on this device', activityNow: 'AI activity now', monitoringOff: 'Ready to observe', stopped: 'READY', workingNow: 'WORKING NOW', openIdle: 'READY', notRunning: 'MONITORING',
+        startHelp: 'Start monitoring to see supported AI work as it happens.', summaryPreserved: 'Your AI Footprint is saved locally. Continue whenever you want.', monitoringStopped: 'Observation ready',
+        workingEvidence: 'Supported AI work is happening now.', idleEvidence: 'Your supported AI app is ready. Forkit will highlight it when work begins.', noApp: 'Ready for your next AI session', noAppHelp: 'Monitoring is active and will surface supported AI work as it happens.',
+        observed: 'Observed', validAwake: 'valid awake time', aiActive: 'AI active', supportedWork: 'supported app work', activityRatio: 'Activity ratio', ratioNote: 'active ÷ observed', overhead: 'Forkit overhead', measuredLocally: 'measured locally', warmingUp: 'measuring…', working: 'Working', openIdleLegend: 'Ready',
+        startMonitoring: 'Start Monitoring', stopMonitoring: 'Stop Monitoring', clearHistory: 'Clear history', observation: 'Your observation', earlyObservation: 'Your Footprint is taking shape', earlyObservationCopy: 'Every observed minute adds more detail to your AI Footprint.', observationShows: 'What your AI activity shows.',
+        footprint: 'Your AI Footprint', modelRecord: 'model record', modelRecords: 'model records',
+        modelRecordsLabel: 'Model records', loaded: '{count} loaded', modelStorage: 'Model storage', recognizedBytes: 'recognized logical bytes', localEngines: 'Local engines', verifiedAvailable: 'verified available now', createShare: 'Create share card', scanAgain: 'Scan again',
+        optionalComparison: 'Optional global comparison', comparisonQuestion: 'How does your AI activity compare?', comparisonCopy: 'Explore your position among participating Forkit observations.', globalProgress: 'Your global comparison is taking shape · {remaining} until it’s ready.', seeGlobal: 'See my global position', reviewSharing: 'Review before sharing.', payloadIntro: 'This is the complete aggregate that would leave this device:', shareCompare: 'Share aggregates & compare', keepLocal: 'Keep everything local', noIdentity: 'No account or device identifier. Global contribution is not available in this version.',
+        technical: 'Technical details', engines: 'Available engines', modelsDevice: 'Models in use', appsTools: 'AI apps running', probeNotes: 'Probe notes', measurementBoundary: 'How Forkit measures', activityMeasurement: 'AI activity', loadedModel: 'Loaded model', storage: 'Model storage', notMeasured: 'Not measured', forkitResources: 'Forkit resources',
+        workingBoundary: 'Recent activity from supported AI app processes.', loadedBoundary: 'Provider-confirmed loaded model.', storageBoundary: 'Recognized local model file sizes.', notMeasuredCopy: 'Prompts, tokens, energy, cost, GPU attribution, per-app network traffic, or exclusive task ownership.',
+        noEngine: '', installedNoLoaded: '', modelsLoaded: '{count} {models} loaded', model: 'model', models: 'models', stored: 'stored', noModel: '', processActivity: 'Running locally', detectedNotRunning: '', noTool: '', noProbe: '',
+        noPrivateFooter: 'No weights, prompts, commands, paths, config values, account data, or upload', shareTitle: 'Your AI Footprint', shareHeading: 'Your measured AI activity.', share: 'Share', savePng: 'Save PNG', copyImage: 'Copy Image', copyCaption: 'Copy Caption', close: 'Close', sharePrivacy: 'Measured totals and supported tool names only. Chat titles, workspaces, paths, and device identity stay out.', copied: 'Copied', copyUnavailable: 'Image copy is unavailable in this system view. Save the PNG instead.',
+        myFootprint: 'MY AI FOOTPRINT', activeTool: 'ACTIVE TOOL', activeTools: 'ACTIVE TOOLS', localModels: 'LOCAL MODELS', observedLocally: 'Observed locally · Forkit AI Footprint', deviceQuestion: 'How much AI is working on your device?', shareActive: 'AI-ACTIVE',
+        clearConfirm: 'Clear this local monitoring history?', scanning: 'Scanning local metadata…', refreshed: 'Footprint refreshed locally.', scanFailed: 'Scan could not be refreshed.',
+        activeShareFallback: 'Supported AI tools were working during {ratio} of this observation.', footprintFallback: '{count} supported local {records} found.', shareActivity: 'Observed {observed}; AI-active {active} ({ratio}).', shareTool: 'Supported AI activity: {tools}.', shareModels: '{count} local {models}; {storage} recognized model files.', captionFirst: 'My AI was actively working during {ratio} of this observation.', captionQuestion: 'How much AI is actually working on your device?',
+        appTitle: 'Forkit AI Footprint', menuStopped: '○ Stopped', menuMonitoring: '● Monitoring', menuWorking: '● Monitoring · {count} working', openFootprint: 'Open AI Footprint', quitForkit: 'Quit Forkit', serviceUnavailable: '○ Service unavailable', serviceStopped: 'Service stopped',
+        closeTitle: 'Forkit will keep monitoring in the background.', closeBody: 'You can reopen it or stop monitoring anytime from the Forkit icon. If the macOS menu bar is hidden, move the pointer to the top edge to reveal it.', gotIt: 'Got it', dontShow: "Don’t show this again", quitTitle: 'Stop monitoring and quit?', keepMonitoring: 'Keep Monitoring', stopQuit: 'Stop & Quit', fatalService: 'The local AI Footprints service could not start.', fatalStopped: 'The local service stopped unexpectedly. No monitoring remains active.', quit: 'Quit',
+        insightMostlyIdle: 'This observation captured a light AI activity pattern.', insightActivityProduct: '{product} was working during {percent}% of your observation.', insightActivityGeneric: 'Supported AI tools were working during {percent}% of your observation.', insightLongest: 'Your longest continuous AI-active period was {duration}.', insightMulti: 'Active AI work was observed across {count} supported tools.', insightModelsUnused: '{count} local models are ready for a future session.', insightFocused: 'All observed AI activity came from {product}.',
+    },
+    de: {
+        localDevice: 'Lokal auf diesem Gerät', activityNow: 'KI-Aktivität jetzt', monitoringOff: 'Bereit zur Beobachtung', stopped: 'BEREIT', workingNow: 'ARBEITET JETZT', openIdle: 'BEREIT', notRunning: 'MONITORING',
+        startHelp: 'Starten Sie das Monitoring und sehen Sie unterstützte KI-Arbeit in Echtzeit.', summaryPreserved: 'Ihr AI Footprint ist lokal gespeichert. Sie können jederzeit fortfahren.', monitoringStopped: 'Beobachtung bereit',
+        workingEvidence: 'Unterstützte KI-Arbeit findet gerade statt.', idleEvidence: 'Ihre unterstützte KI-App ist bereit. Forkit hebt sie hervor, sobald die Arbeit beginnt.', noApp: 'Bereit für Ihre nächste KI-Sitzung', noAppHelp: 'Das Monitoring ist aktiv und zeigt unterstützte KI-Arbeit, sobald sie stattfindet.',
+        observed: 'Beobachtet', validAwake: 'gültige aktive Gerätezeit', aiActive: 'KI aktiv', supportedWork: 'Arbeit unterstützter Apps', activityRatio: 'Aktivitätsanteil', ratioNote: 'aktiv ÷ beobachtet', overhead: 'Forkit-Ressourcen', measuredLocally: 'lokal gemessen', warmingUp: 'wird gemessen…', working: 'Arbeitet', openIdleLegend: 'Bereit',
+        startMonitoring: 'Monitoring starten', stopMonitoring: 'Monitoring stoppen', clearHistory: 'Verlauf löschen', observation: 'Ihre Beobachtung', earlyObservation: 'Ihr Footprint nimmt Gestalt an', earlyObservationCopy: 'Jede beobachtete Minute ergänzt Ihren AI Footprint.', observationShows: 'Das zeigt Ihre KI-Aktivität.',
+        footprint: 'Ihr AI Footprint', modelRecord: 'Modelldatensatz', modelRecords: 'Modelldatensätze',
+        modelRecordsLabel: 'Modelldatensätze', loaded: '{count} geladen', modelStorage: 'Modellspeicher', recognizedBytes: 'erkannte logische Dateibytes', localEngines: 'Lokale Engines', verifiedAvailable: 'aktuell verifiziert verfügbar', createShare: 'Share-Karte erstellen', scanAgain: 'Erneut scannen',
+        optionalComparison: 'Optionaler globaler Vergleich', comparisonQuestion: 'Wie lässt sich Ihre KI-Aktivität vergleichen?', comparisonCopy: 'Entdecken Sie Ihre Position unter teilnehmenden Forkit-Beobachtungen.', globalProgress: 'Ihr globaler Vergleich nimmt Gestalt an · in {remaining} ist er bereit.', seeGlobal: 'Meine globale Position ansehen', reviewSharing: 'Vor dem Teilen prüfen.', payloadIntro: 'Dies ist das vollständige Aggregat, das dieses Gerät verlassen würde:', shareCompare: 'Aggregate teilen & vergleichen', keepLocal: 'Alles lokal behalten', noIdentity: 'Kein Konto und keine Gerätekennung. Globale Beiträge sind in dieser Version nicht verfügbar.',
+        technical: 'Technische Details', engines: 'Verfügbare Engines', modelsDevice: 'Modelle in Verwendung', appsTools: 'Laufende KI-Apps', probeNotes: 'Prüfhinweise', measurementBoundary: 'So misst Forkit', activityMeasurement: 'KI-Aktivität', loadedModel: 'Geladenes Modell', storage: 'Modellspeicher', notMeasured: 'Nicht gemessen', forkitResources: 'Forkit-Ressourcen',
+        workingBoundary: 'Aktuelle Aktivität unterstützter KI-App-Prozesse.', loadedBoundary: 'Vom Anbieter bestätigtes geladenes Modell.', storageBoundary: 'Erkannte lokale Modelldateigrößen.', notMeasuredCopy: 'Prompts, Tokens, Energie, Kosten, GPU-Zuordnung, Netzwerkverkehr pro App oder exklusive Aufgabenzuordnung.',
+        noEngine: '', installedNoLoaded: '', modelsLoaded: '{count} {models} geladen', model: 'Modell', models: 'Modelle', stored: 'gespeichert', noModel: '', processActivity: 'Läuft lokal', detectedNotRunning: '', noTool: '', noProbe: '',
+        noPrivateFooter: 'Keine Gewichte, Prompts, Befehle, Pfade, Konfigurationswerte, Kontodaten oder Uploads', shareTitle: 'Ihr AI Footprint', shareHeading: 'Ihre gemessene KI-Aktivität.', share: 'Teilen', savePng: 'PNG speichern', copyImage: 'Bild kopieren', copyCaption: 'Text kopieren', close: 'Schließen', sharePrivacy: 'Nur gemessene Summen und Namen unterstützter Tools. Chat-Titel, Workspaces, Pfade und Gerätekennung bleiben außen vor.', copied: 'Kopiert', copyUnavailable: 'Das Kopieren von Bildern ist in dieser Systemansicht nicht verfügbar. Speichern Sie stattdessen die PNG-Datei.',
+        myFootprint: 'MEIN AI FOOTPRINT', activeTool: 'AKTIVES TOOL', activeTools: 'AKTIVE TOOLS', localModels: 'LOKALE MODELLE', observedLocally: 'Lokal beobachtet · Forkit AI Footprint', deviceQuestion: 'Wie viel KI arbeitet auf Ihrem Gerät?', shareActive: 'KI-AKTIV',
+        clearConfirm: 'Diesen lokalen Monitoring-Verlauf löschen?', scanning: 'Lokale Metadaten werden gescannt…', refreshed: 'Footprint lokal aktualisiert.', scanFailed: 'Der Scan konnte nicht aktualisiert werden.',
+        activeShareFallback: 'Unterstützte KI-Tools arbeiteten während {ratio} dieser Beobachtung.', footprintFallback: '{count} unterstützte lokale {records} gefunden.', shareActivity: '{observed} beobachtet; KI aktiv {active} ({ratio}).', shareTool: 'Unterstützte KI-Aktivität: {tools}.', shareModels: '{count} lokale {models}; {storage} erkannte Modelldateien.', captionFirst: 'Meine KI arbeitete während {ratio} dieser Beobachtung aktiv.', captionQuestion: 'Wie viel KI arbeitet tatsächlich auf Ihrem Gerät?',
+        appTitle: 'Forkit AI Footprint', menuStopped: '○ Gestoppt', menuMonitoring: '● Monitoring', menuWorking: '● Monitoring · {count} aktiv', openFootprint: 'AI Footprint öffnen', quitForkit: 'Forkit beenden', serviceUnavailable: '○ Dienst nicht verfügbar', serviceStopped: 'Dienst gestoppt',
+        closeTitle: 'Forkit überwacht im Hintergrund weiter.', closeBody: 'Über das Forkit-Symbol können Sie die App jederzeit erneut öffnen oder das Monitoring stoppen. Falls die macOS-Menüleiste ausgeblendet ist, bewegen Sie den Zeiger an den oberen Bildschirmrand.', gotIt: 'Verstanden', dontShow: 'Nicht erneut anzeigen', quitTitle: 'Monitoring stoppen und beenden?', keepMonitoring: 'Monitoring fortsetzen', stopQuit: 'Stoppen & beenden', fatalService: 'Der lokale AI-Footprints-Dienst konnte nicht gestartet werden.', fatalStopped: 'Der lokale Dienst wurde unerwartet beendet. Es ist kein Monitoring mehr aktiv.', quit: 'Beenden',
+        insightMostlyIdle: 'Diese Beobachtung zeigt ein leichtes KI-Aktivitätsmuster.', insightActivityProduct: '{product} arbeitete während {percent} % Ihrer Beobachtung.', insightActivityGeneric: 'Unterstützte KI-Tools arbeiteten während {percent} % Ihrer Beobachtung.', insightLongest: 'Ihr längster durchgehender KI-aktiver Zeitraum dauerte {duration}.', insightMulti: 'Aktive KI-Arbeit wurde in {count} unterstützten Tools beobachtet.', insightModelsUnused: '{count} lokale Modelle sind für eine zukünftige Sitzung bereit.', insightFocused: 'Die gesamte beobachtete KI-Aktivität stammte von {product}.',
+    },
+};
+function normalizeLocale(value) { return String(value || '').toLowerCase().startsWith('de') ? 'de' : 'en'; }
+function uiText(locale, key, values = {}) {
+    let text = exports.UI_COPY[locale][key];
+    for (const [name, value] of Object.entries(values))
+        text = text.replaceAll(`{${name}}`, String(value));
+    return text;
+}
+//# sourceMappingURL=localization.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/mcp.d.ts

@@ -0,0 +1,9 @@
+import type { CensusMcpConfig } from './types';
+export interface McpDetectionOptions {
+    homeDir: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    platform: NodeJS.Platform;
+}
+export declare function detectMcpConfigs(options: McpDetectionOptions): Promise<CensusMcpConfig[]>;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/mcp.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectMcpConfigs = detectMcpConfigs;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+function configRoot(options) {
+    if (options.platform === 'win32') {
+        return options.env.APPDATA || node_path_1.default.join(options.homeDir, 'AppData', 'Roaming');
+    }
+    if (options.platform === 'darwin')
+        return node_path_1.default.join(options.homeDir, 'Library', 'Application Support');
+    return options.env.XDG_CONFIG_HOME || node_path_1.default.join(options.homeDir, '.config');
+}
+function candidates(options) {
+    const root = configRoot(options);
+    return [
+        { client: 'Claude Desktop', filePath: node_path_1.default.join(root, 'Claude', 'claude_desktop_config.json'), format: 'json' },
+        { client: 'Claude Code', filePath: node_path_1.default.join(options.homeDir, '.claude.json'), format: 'json' },
+        { client: 'Codex', filePath: node_path_1.default.join(options.homeDir, '.codex', 'config.toml'), format: 'toml' },
+        { client: 'Cursor', filePath: node_path_1.default.join(options.homeDir, '.cursor', 'mcp.json'), format: 'json' },
+        { client: 'Cursor (workspace)', filePath: node_path_1.default.join(options.cwd, '.cursor', 'mcp.json'), format: 'json' },
+        { client: 'Windsurf', filePath: node_path_1.default.join(options.homeDir, '.codeium', 'windsurf', 'mcp_config.json'), format: 'json' },
+        { client: 'VS Code', filePath: node_path_1.default.join(root, 'Code', 'User', 'mcp.json'), format: 'json' },
+        { client: 'VS Code Insiders', filePath: node_path_1.default.join(root, 'Code - Insiders', 'User', 'mcp.json'), format: 'json' },
+        { client: 'Gemini CLI', filePath: node_path_1.default.join(options.homeDir, '.gemini', 'settings.json'), format: 'json' },
+        { client: 'OpenCode', filePath: node_path_1.default.join(options.homeDir, '.config', 'opencode', 'opencode.json'), format: 'json' },
+        { client: 'Zed', filePath: node_path_1.default.join(options.homeDir, '.zed', 'settings.json'), format: 'json' },
+        { client: 'Zed (workspace)', filePath: node_path_1.default.join(options.cwd, '.zed', 'settings.json'), format: 'json' },
+    ];
+}
+function jsonServerCount(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return 0;
+    const record = value;
+    if (record.mcpServers && typeof record.mcpServers === 'object' && !Array.isArray(record.mcpServers)) {
+        return Object.keys(record.mcpServers).length;
+    }
+    if (record.mcp && typeof record.mcp === 'object' && !Array.isArray(record.mcp)) {
+        const servers = record.mcp.servers;
+        if (servers && typeof servers === 'object' && !Array.isArray(servers)) {
+            return Object.keys(servers).length;
+        }
+    }
+    if (record.context_servers && typeof record.context_servers === 'object' && !Array.isArray(record.context_servers)) {
+        return Object.keys(record.context_servers).length;
+    }
+    return 0;
+}
+async function inspect(candidate) {
+    let handle = null;
+    try {
+        handle = await promises_1.default.open(candidate.filePath, 'r');
+        const stats = await handle.stat();
+        if (!stats.isFile() || stats.size > 1024 * 1024)
+            return null;
+        const content = await handle.readFile({ encoding: 'utf8' });
+        const serverCount = candidate.format === 'json'
+            ? jsonServerCount(JSON.parse(content))
+            : [...content.matchAll(/^\s*\[mcp_servers\.[^\]]+\]\s*$/gm)].length;
+        if (serverCount === 0)
+            return null;
+        return {
+            client: candidate.client,
+            evidence_status: 'configured',
+            confidence: 'high',
+            server_count: serverCount,
+        };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+async function detectMcpConfigs(options) {
+    const seenPaths = new Set();
+    const uniqueCandidates = candidates(options).filter((candidate) => {
+        const normalized = node_path_1.default.resolve(candidate.filePath);
+        if (seenPaths.has(normalized))
+            return false;
+        seenPaths.add(normalized);
+        return true;
+    });
+    const findings = await Promise.all(uniqueCandidates.map((candidate) => inspect(candidate)));
+    return findings
+        .filter((finding) => finding !== null)
+        .sort((left, right) => left.client.localeCompare(right.client));
+}
+//# sourceMappingURL=mcp.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/monitor.d.ts

@@ -0,0 +1,99 @@
+import { type ClassifiedAgentProcess } from './agents';
+import type { ProcessEntry } from './types';
+export type AiActivityState = 'working-now' | 'open-idle' | 'not-running';
+export type MonitorLifecycle = 'stopped' | 'monitoring';
+export interface ActivityContext {
+    chat: string | null;
+    workspace: string | null;
+    source: 'cooperating-app-metadata' | null;
+}
+export interface AiActivityProduct {
+    signature: string;
+    name: string;
+    kind: string;
+    state: AiActivityState;
+    process_count: number;
+    cpu_percent: number | null;
+    memory_percent: number | null;
+    recent_cpu_time_delta_ms: number | null;
+    active_seconds: number;
+    context: ActivityContext;
+}
+export interface ActivityTimelineSegment {
+    started_at: string;
+    ended_at: string;
+    state: 'working-now' | 'open-idle' | 'not-running';
+    product_signatures: string[];
+    observation_id?: number;
+}
+export interface MonitorOverhead {
+    current_cpu_percent: number | null;
+    current_memory_bytes: number;
+    history_bytes: number;
+    sample_count: number;
+    median_cpu_percent: number | null;
+    p95_cpu_percent: number | null;
+    max_memory_bytes: number;
+    measurement: 'forkit-process-tree';
+}
+export interface MonitorSnapshot {
+    schema_version: '1.0';
+    lifecycle: MonitorLifecycle;
+    started_at: string | null;
+    stopped_at: string | null;
+    observed_seconds: number;
+    active_seconds: number;
+    activity_ratio: number | null;
+    products: AiActivityProduct[];
+    timeline: ActivityTimelineSegment[];
+    overhead: MonitorOverhead;
+    sample_interval_ms: number;
+    history_limit: number;
+    evidence: 'repeated-process-tree-cpu-time-deltas';
+    limitation: string;
+}
+export interface ActivityMonitorOptions {
+    sampleProcesses?: () => Promise<ProcessEntry[]>;
+    now?: () => number;
+    intervalMs?: number;
+    historyLimit?: number;
+    excludedRootPid?: number | null;
+    context?: () => ActivityContext;
+    classifyProcesses?: (processes: ProcessEntry[]) => ClassifiedAgentProcess[] | Promise<ClassifiedAgentProcess[]>;
+}
+export declare class ActivityMonitor {
+    private readonly sampleProcesses;
+    private readonly now;
+    private readonly intervalMs;
+    private readonly historyLimit;
+    private readonly excludedRootPid;
+    private readonly context;
+    private readonly classifyProcesses;
+    private lifecycle;
+    private startedAt;
+    private stoppedAt;
+    private previousAt;
+    private observationId;
+    private previousCpuTimes;
+    private observedMs;
+    private activeMs;
+    private products;
+    private timeline;
+    private timer;
+    private sampling;
+    private nodeCpuUsage;
+    private nodeCpuAt;
+    private overheadCpuSamples;
+    private overheadMemorySamples;
+    constructor(options?: ActivityMonitorOptions);
+    start(options?: {
+        schedule?: boolean;
+    }): Promise<MonitorSnapshot>;
+    sampleNow(): Promise<MonitorSnapshot>;
+    stop(): MonitorSnapshot;
+    clearHistory(): MonitorSnapshot;
+    private updateTimeline;
+    private sampleOverhead;
+    snapshot(): MonitorSnapshot;
+}
+//# sourceMappingURL=monitor.d.ts.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/monitor.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityMonitor = void 0;
+const agents_1 = require("./agents");
+const DEFAULT_INTERVAL_MS = 1000;
+const DEFAULT_HISTORY_LIMIT = 900;
+function rounded(value, digits = 1) {
+    const factor = 10 ** digits;
+    return Math.round(value * factor) / factor;
+}
+function sum(values) {
+    const measured = values.filter((value) => value !== null);
+    return measured.length === 0 ? null : rounded(measured.reduce((total, value) => total + value, 0));
+}
+function percentile(values, fraction) {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((left, right) => left - right);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * fraction) - 1));
+    return rounded(sorted[index]);
+}
+function localContextFromEnvironment() {
+    const chat = process.env.FORKIT_AI_FOOTPRINTS_CONTEXT_CHAT?.trim() || null;
+    const workspace = process.env.FORKIT_AI_FOOTPRINTS_CONTEXT_WORKSPACE?.trim() || null;
+    return {
+        chat,
+        workspace,
+        source: chat || workspace ? 'cooperating-app-metadata' : null,
+    };
+}
+function groupProcesses(processes) {
+    const result = new Map();
+    for (const entry of processes)
+        result.set(entry.signature, [...(result.get(entry.signature) ?? []), entry]);
+    return result;
+}
+function historyByteSize(snapshot) {
+    return Buffer.byteLength(JSON.stringify({
+        started_at: snapshot.started_at,
+        observed_seconds: snapshot.observed_seconds,
+        active_seconds: snapshot.active_seconds,
+        products: snapshot.products,
+        timeline: snapshot.timeline,
+    }));
+}
+class ActivityMonitor {
+    sampleProcesses;
+    now;
+    intervalMs;
+    historyLimit;
+    excludedRootPid;
+    context;
+    classifyProcesses;
+    lifecycle = 'stopped';
+    startedAt = null;
+    stoppedAt = null;
+    previousAt = null;
+    observationId = 0;
+    previousCpuTimes = new Map();
+    observedMs = 0;
+    activeMs = 0;
+    products = new Map();
+    timeline = [];
+    timer = null;
+    sampling = false;
+    nodeCpuUsage = null;
+    nodeCpuAt = null;
+    overheadCpuSamples = [];
+    overheadMemorySamples = [];
+    constructor(options = {}) {
+        this.sampleProcesses = options.sampleProcesses ?? agents_1.listSystemProcesses;
+        this.now = options.now ?? Date.now;
+        this.intervalMs = Math.max(500, options.intervalMs ?? DEFAULT_INTERVAL_MS);
+        this.historyLimit = Math.max(10, options.historyLimit ?? DEFAULT_HISTORY_LIMIT);
+        this.excludedRootPid = options.excludedRootPid === undefined ? process.pid : options.excludedRootPid;
+        this.context = options.context ?? localContextFromEnvironment;
+        this.classifyProcesses = options.classifyProcesses ?? ((entries) => (0, agents_1.classifyAgentProcessTrees)(entries, this.excludedRootPid));
+    }
+    async start(options = {}) {
+        if (this.lifecycle === 'monitoring')
+            return this.snapshot();
+        const now = this.now();
+        this.lifecycle = 'monitoring';
+        this.observationId += 1;
+        this.startedAt = now;
+        this.stoppedAt = null;
+        this.previousAt = null;
+        this.previousCpuTimes.clear();
+        this.nodeCpuUsage = process.cpuUsage();
+        this.nodeCpuAt = now;
+        await this.sampleNow();
+        if (options.schedule !== false) {
+            this.timer = setInterval(() => { void this.sampleNow(); }, this.intervalMs);
+            this.timer.unref();
+        }
+        return this.snapshot();
+    }
+    async sampleNow() {
+        if (this.lifecycle !== 'monitoring' || this.sampling)
+            return this.snapshot();
+        this.sampling = true;
+        try {
+            const entries = await this.sampleProcesses();
+            const now = this.now();
+            const elapsed = this.previousAt === null ? 0 : Math.max(0, now - this.previousAt);
+            const validElapsed = elapsed > 0 && elapsed <= this.intervalMs * 3 ? elapsed : 0;
+            const grouped = groupProcesses(await this.classifyProcesses(entries));
+            const signatures = new Set([...this.products.keys(), ...grouped.keys()]);
+            for (const signature of signatures) {
+                const current = grouped.get(signature) ?? [];
+                const previous = this.products.get(signature);
+                let cpuDeltaMs = 0;
+                let deltaCount = 0;
+                for (const entry of current) {
+                    const currentTime = entry.cpu_time_ms;
+                    const previousTime = this.previousCpuTimes.get(entry.pid);
+                    if (currentTime === null || previousTime === undefined || currentTime < previousTime)
+                        continue;
+                    cpuDeltaMs += currentTime - previousTime;
+                    deltaCount += 1;
+                }
+                const measuredDelta = deltaCount > 0 ? cpuDeltaMs : null;
+                const strongSignal = current.length > 0
+                    && validElapsed > 0
+                    && measuredDelta !== null
+                    && measuredDelta >= Math.max(20, validElapsed * 0.02);
+                const signals = [...(previous?.signals ?? []), strongSignal].slice(-3);
+                let state;
+                if (current.length === 0)
+                    state = 'not-running';
+                else if (previous?.state === 'working-now')
+                    state = signals.every((value) => !value) ? 'open-idle' : 'working-now';
+                else
+                    state = signals.slice(-2).length === 2 && signals.slice(-2).every(Boolean) ? 'working-now' : 'open-idle';
+                const activeMs = (previous?.activeMs ?? 0) + (validElapsed > 0 && state === 'working-now' ? validElapsed : 0);
+                const first = current[0];
+                this.products.set(signature, {
+                    signature,
+                    name: first?.name ?? previous?.name ?? signature,
+                    kind: first?.kind ?? previous?.kind ?? 'unknown',
+                    state,
+                    signals,
+                    activeMs,
+                    processCount: current.length,
+                    cpuPercent: sum(current.map((entry) => entry.cpu_percent)),
+                    memoryPercent: sum(current.map((entry) => entry.memory_percent)),
+                    cpuDeltaMs: measuredDelta,
+                });
+            }
+            if (validElapsed > 0) {
+                this.observedMs += validElapsed;
+                if ([...this.products.values()].some((product) => product.state === 'working-now'))
+                    this.activeMs += validElapsed;
+            }
+            this.updateTimeline(now);
+            this.previousCpuTimes = new Map(entries.flatMap((entry) => Number.isFinite(entry.cpu_time_ms)
+                ? [[entry.pid, Number(entry.cpu_time_ms)]]
+                : []));
+            this.previousAt = now;
+            this.sampleOverhead(now, entries);
+            return this.snapshot();
+        }
+        finally {
+            this.sampling = false;
+        }
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        if (this.lifecycle === 'monitoring')
+            this.stoppedAt = this.now();
+        this.lifecycle = 'stopped';
+        return this.snapshot();
+    }
+    clearHistory() {
+        const now = this.now();
+        this.startedAt = this.lifecycle === 'monitoring' ? now : null;
+        this.stoppedAt = null;
+        this.previousAt = null;
+        this.previousCpuTimes.clear();
+        this.observedMs = 0;
+        this.activeMs = 0;
+        this.products.clear();
+        this.timeline = [];
+        this.overheadCpuSamples = [];
+        this.overheadMemorySamples = [];
+        this.nodeCpuUsage = process.cpuUsage();
+        this.nodeCpuAt = now;
+        return this.snapshot();
+    }
+    updateTimeline(now) {
+        const working = [...this.products.values()].filter((product) => product.state === 'working-now');
+        const running = [...this.products.values()].filter((product) => product.state !== 'not-running');
+        const state = working.length > 0
+            ? 'working-now'
+            : running.length > 0 ? 'open-idle' : 'not-running';
+        const signatures = (working.length > 0 ? working : running).map((product) => product.signature).sort();
+        const at = new Date(now).toISOString();
+        const latest = this.timeline.at(-1);
+        if (latest && latest.observation_id === this.observationId && latest.state === state && latest.product_signatures.join('|') === signatures.join('|'))
+            latest.ended_at = at;
+        else
+            this.timeline.push({ started_at: at, ended_at: at, state, product_signatures: signatures, observation_id: this.observationId });
+        if (this.timeline.length > this.historyLimit)
+            this.timeline.splice(0, this.timeline.length - this.historyLimit);
+    }
+    sampleOverhead(now, entries) {
+        const included = new Set([process.pid]);
+        if (process.env.FORKIT_AI_FOOTPRINTS_APP_BUNDLE === '1' && process.ppid > 1)
+            included.add(process.ppid);
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const entry of entries) {
+                if (included.has(entry.pid) || entry.ppid === undefined || !included.has(entry.ppid))
+                    continue;
+                included.add(entry.pid);
+                changed = true;
+            }
+        }
+        const ownEntries = entries.filter((entry) => included.has(entry.pid));
+        const measuredMemory = ownEntries.reduce((total, entry) => total + (Number.isFinite(entry.rss_bytes) ? Number(entry.rss_bytes) : 0), 0);
+        const memory = measuredMemory > 0 ? measuredMemory : process.memoryUsage().rss;
+        this.overheadMemorySamples.push(memory);
+        if (this.overheadMemorySamples.length > this.historyLimit)
+            this.overheadMemorySamples.shift();
+        if (this.nodeCpuUsage && this.nodeCpuAt !== null && now - this.nodeCpuAt >= this.intervalMs * 0.5) {
+            const usage = process.cpuUsage(this.nodeCpuUsage);
+            const nodeCpu = ((usage.user + usage.system) / ((now - this.nodeCpuAt) * 1000)) * 100;
+            const measuredTreeCpu = ownEntries.reduce((total, entry) => total + (Number.isFinite(entry.cpu_percent) ? Number(entry.cpu_percent) : 0), 0);
+            const cpu = process.env.FORKIT_AI_FOOTPRINTS_APP_BUNDLE === '1' && measuredTreeCpu > 0 ? measuredTreeCpu : nodeCpu;
+            this.overheadCpuSamples.push(rounded(Math.max(0, cpu)));
+            if (this.overheadCpuSamples.length > this.historyLimit)
+                this.overheadCpuSamples.shift();
+        }
+        this.nodeCpuUsage = process.cpuUsage();
+        this.nodeCpuAt = now;
+    }
+    snapshot() {
+        const products = [...this.products.values()].map((product) => ({
+            signature: product.signature,
+            name: product.name,
+            kind: product.kind,
+            state: product.state,
+            process_count: product.processCount,
+            cpu_percent: product.cpuPercent,
+            memory_percent: product.memoryPercent,
+            recent_cpu_time_delta_ms: product.cpuDeltaMs,
+            active_seconds: rounded(product.activeMs / 1000),
+            context: this.context(),
+        })).sort((left, right) => left.name.localeCompare(right.name));
+        const base = {
+            schema_version: '1.0',
+            lifecycle: this.lifecycle,
+            started_at: this.startedAt === null ? null : new Date(this.startedAt).toISOString(),
+            stopped_at: this.stoppedAt === null ? null : new Date(this.stoppedAt).toISOString(),
+            observed_seconds: rounded(this.observedMs / 1000),
+            active_seconds: rounded(this.activeMs / 1000),
+            activity_ratio: this.observedMs > 0 ? rounded(this.activeMs / this.observedMs, 3) : null,
+            products,
+            timeline: this.timeline.map((segment) => ({ ...segment, product_signatures: [...segment.product_signatures] })),
+            sample_interval_ms: this.intervalMs,
+            history_limit: this.historyLimit,
+            evidence: 'repeated-process-tree-cpu-time-deltas',
+            limitation: 'Working now means sustained recent work in a supported app process tree; it is not prompt, task, token, energy, or cost attribution.',
+        };
+        const memory = this.overheadMemorySamples.at(-1) ?? process.memoryUsage().rss;
+        return {
+            ...base,
+            overhead: {
+                current_cpu_percent: this.overheadCpuSamples.at(-1) ?? null,
+                current_memory_bytes: memory,
+                history_bytes: historyByteSize(base),
+                sample_count: this.overheadCpuSamples.length,
+                median_cpu_percent: percentile(this.overheadCpuSamples, 0.5),
+                p95_cpu_percent: percentile(this.overheadCpuSamples, 0.95),
+                max_memory_bytes: Math.max(memory, ...this.overheadMemorySamples),
+                measurement: 'forkit-process-tree',
+            },
+        };
+    }
+}
+exports.ActivityMonitor = ActivityMonitor;
+//# sourceMappingURL=monitor.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/providers/base.d.ts

@@ -0,0 +1,34 @@
+import type { CensusModel, CensusRuntime, Confidence, RuntimeKind, RuntimeStatus } from '../types';
+export declare function fetchJson(url: string, init: RequestInit, fetchImpl: typeof fetch, timeoutMs?: number): Promise<{
+    ok: boolean;
+    status: number;
+    body: unknown;
+    error: string | null;
+}>;
+export declare function createRuntime(input: {
+    name: RuntimeKind;
+    endpoint: string | null;
+    status: RuntimeStatus;
+    modelCount: number;
+    observedAt: string;
+    errorCode?: string | null;
+}): CensusRuntime;
+export declare function createModel(input: {
+    name: string;
+    runtime: RuntimeKind;
+    identityKind: CensusModel['identity_kind'];
+    identity: string;
+    source: CensusModel['source'];
+    confidence: Confidence;
+    sizeBytes?: number | null;
+    modifiedAt?: string | null;
+    quantization?: string | null;
+    architecture?: string | null;
+    parameterSize?: string | null;
+    locationHint?: string | null;
+}): CensusModel;
+export declare function readRecord(value: unknown): Record<string, unknown> | null;
+export declare function readArray(value: unknown): unknown[];
+export declare function readString(value: unknown): string | null;
+export declare function readNumber(value: unknown): number | null;
+//# sourceMappingURL=base.d.ts.map