forkit-ai-footprints 0.2.0

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

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+interface ParsedOptions {
+    command: 'install' | 'help' | 'version' | 'scan' | 'monitor' | 'doctor' | 'evaluate' | 'aggregate' | 'share-page' | 'serve';
+    json: boolean;
+    output: string | null;
+    includeRuntimes: boolean;
+    includeFilesystem: boolean;
+    includeAgents: boolean;
+    includeTools: boolean;
+    includeMcp: boolean;
+    modelDirs: string[];
+    verbose: boolean;
+    copy: boolean;
+    guess: number | null;
+    anonymousPayload: boolean;
+    shareConsent: boolean;
+    truth: string | null;
+    results: string | null;
+    port: number;
+}
+export declare function parseArgs(args: string[]): ParsedOptions;
+export declare function installPersistentMacApp(options?: {
+    applicationsDirectory?: string;
+    open?: boolean;
+}): Promise<string>;
+export declare function clipboardCommands(platform: NodeJS.Platform): Array<{
+    command: string;
+    args: string[];
+}>;
+export declare function main(args?: string[]): Promise<number>;
+export {};
+//# sourceMappingURL=cli.d.ts.map

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

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.installPersistentMacApp = installPersistentMacApp;
+exports.clipboardCommands = clipboardCommands;
+exports.main = main;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_child_process_1 = require("node:child_process");
+const census_1 = require("./census");
+const doctor_1 = require("./doctor");
+const format_1 = require("./format");
+const version_1 = require("./version");
+const monitor_1 = require("./monitor");
+const evaluate_1 = require("./evaluate");
+const aggregate_1 = require("./aggregate");
+const share_page_1 = require("./share-page");
+const server_1 = require("./server");
+const local_device_1 = require("./local-device");
+const HELP = `Forkit AI Footprints
+Private, metadata-only local AI inventory.
+Apple Silicon macOS local release.
+
+Usage:
+  forkit-ai-footprints
+  forkit-ai-footprints serve [--port 47811]
+  forkit-ai-footprints monitor [--json]
+  forkit-ai-footprints scan [options]
+  forkit-ai-footprints doctor [--json]
+  forkit-ai-footprints share-page --output /path/to/local-ai-footprint.html
+  forkit-ai-footprints --version
+
+Options:
+  --json                 Print a machine-readable AI Footprint report
+  --verbose              Show detector and identity details
+  --guess <count>        Compare your estimate with discovered models
+  --copy                 Copy the rendered local result to the clipboard
+  --anonymous-payload    Reserved for a completed 10-minute monitor session
+  --consent-share        Separate consent; never enables upload in this build
+  --output <file>        Save the selected human or JSON report
+  --model-dir <path>     Inspect an explicit model directory; repeatable
+  --truth <file>         Evaluate locally against manually labelled macOS truth
+  --results <directory>  Aggregate local macOS evaluation JSON files
+  --port <number>        Local-only serve port (default: 47811)
+  --no-runtimes          Skip local runtime API discovery
+  --no-model-files       Skip filesystem model metadata discovery
+  --no-agents            Skip local process metadata discovery
+  --no-tools             Skip passive AI-tool detection
+  --no-mcp               Skip known MCP configuration counts
+  -h, --help             Show this help
+
+Privacy:
+  AI Footprints reads metadata only. It does not read model bytes, retain raw process
+  commands or MCP configuration values, authenticate to Forkit.dev, or write to
+  any passport, registry, Runtime_C2, or production service.
+`;
+function parseArgs(args) {
+    let command = 'install';
+    let json = false;
+    let output = null;
+    let includeRuntimes = true;
+    let includeFilesystem = true;
+    let includeAgents = true;
+    let includeTools = true;
+    let includeMcp = true;
+    let verbose = false;
+    let copy = false;
+    let guess = null;
+    let anonymousPayload = false;
+    let shareConsent = false;
+    let truth = null;
+    let results = null;
+    let port = 47811;
+    const modelDirs = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === 'install' || arg === 'install-app')
+            command = 'install';
+        else if (arg === 'scan' || arg === 'report')
+            command = 'scan';
+        else if (arg === 'monitor')
+            command = 'monitor';
+        else if (arg === 'doctor')
+            command = 'doctor';
+        else if (arg === 'evaluate')
+            command = 'evaluate';
+        else if (arg === 'aggregate')
+            command = 'aggregate';
+        else if (arg === 'share-page')
+            command = 'share-page';
+        else if (arg === 'serve')
+            command = 'serve';
+        else if (arg === '--version' || arg === '-V' || arg === 'version')
+            command = 'version';
+        else if (arg === '--help' || arg === '-h' || arg === 'help')
+            command = 'help';
+        else if (arg === '--json')
+            json = true;
+        else if (arg === '--verbose')
+            verbose = true;
+        else if (arg === '--copy')
+            copy = true;
+        else if (arg === '--anonymous-payload')
+            anonymousPayload = true;
+        else if (arg === '--consent-share')
+            shareConsent = true;
+        else if (arg === '--no-runtimes')
+            includeRuntimes = false;
+        else if (arg === '--no-model-files')
+            includeFilesystem = false;
+        else if (arg === '--no-agents')
+            includeAgents = false;
+        else if (arg === '--no-tools')
+            includeTools = false;
+        else if (arg === '--no-mcp')
+            includeMcp = false;
+        else if (arg === '--guess') {
+            const rawGuess = args[index + 1];
+            const parsedGuess = Number(rawGuess);
+            if (!rawGuess || !Number.isFinite(parsedGuess) || parsedGuess < 0) {
+                throw new Error('--guess requires a non-negative number.');
+            }
+            guess = Math.floor(parsedGuess);
+            index += 1;
+        }
+        else if (arg === '--port') {
+            const rawPort = args[index + 1];
+            const parsedPort = Number(rawPort);
+            if (!rawPort || !Number.isSafeInteger(parsedPort) || parsedPort < 1024 || parsedPort > 65535) {
+                throw new Error('--port requires an integer from 1024 to 65535.');
+            }
+            port = parsedPort;
+            index += 1;
+        }
+        else if (arg === '--output') {
+            output = args[index + 1] ?? null;
+            if (!output)
+                throw new Error('--output requires a file path.');
+            index += 1;
+        }
+        else if (arg === '--truth') {
+            truth = args[index + 1] ?? null;
+            if (!truth)
+                throw new Error('--truth requires a file path.');
+            index += 1;
+        }
+        else if (arg === '--results') {
+            results = args[index + 1] ?? null;
+            if (!results)
+                throw new Error('--results requires a directory path.');
+            index += 1;
+        }
+        else if (arg === '--model-dir') {
+            const directory = args[index + 1];
+            if (!directory)
+                throw new Error('--model-dir requires a directory path.');
+            modelDirs.push(directory);
+            index += 1;
+        }
+        else {
+            throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    return {
+        command,
+        json,
+        output,
+        includeRuntimes,
+        includeFilesystem,
+        includeAgents,
+        includeTools,
+        includeMcp,
+        modelDirs,
+        verbose,
+        copy,
+        guess,
+        anonymousPayload,
+        shareConsent,
+        truth,
+        results,
+        port,
+    };
+}
+async function installPersistentMacApp(options = {}) {
+    if (process.platform !== 'darwin' || process.arch !== 'arm64')
+        throw new Error('The persistent GUI currently supports Apple Silicon macOS only.');
+    const source = node_path_1.default.join(__dirname, 'bootstrap', 'Forkit AI Footprint.app');
+    try {
+        await promises_1.default.access(node_path_1.default.join(source, 'Contents', 'Info.plist'));
+    }
+    catch {
+        throw new Error('This package does not contain the macOS GUI bootstrap. Install from the packed release candidate.');
+    }
+    const applicationsDirectory = options.applicationsDirectory
+        ?? process.env.FORKIT_AI_FOOTPRINTS_APPLICATIONS_DIR
+        ?? node_path_1.default.join(node_os_1.default.homedir(), 'Applications');
+    const destination = node_path_1.default.join(applicationsDirectory, 'Forkit AI Footprint.app');
+    const staging = node_path_1.default.join(applicationsDirectory, `.Forkit AI Footprint.installing-${process.pid}.app`);
+    const previous = node_path_1.default.join(applicationsDirectory, `.Forkit AI Footprint.previous-${process.pid}.app`);
+    await promises_1.default.mkdir(applicationsDirectory, { recursive: true, mode: 0o700 });
+    await promises_1.default.rm(staging, { recursive: true, force: true });
+    await promises_1.default.cp(source, staging, { recursive: true, preserveTimestamps: true });
+    let hadPrevious = false;
+    try {
+        const existingInfo = await promises_1.default.readFile(node_path_1.default.join(destination, 'Contents', 'Info.plist'), 'utf8').catch(() => '');
+        if (existingInfo && !existingInfo.includes('dev.forkit.ai-footprints'))
+            throw new Error('The destination contains a different application.');
+        if (existingInfo) {
+            await promises_1.default.rename(destination, previous);
+            hadPrevious = true;
+        }
+        await promises_1.default.rename(staging, destination);
+        if (hadPrevious)
+            await promises_1.default.rm(previous, { recursive: true, force: true });
+    }
+    catch (error) {
+        await promises_1.default.rm(staging, { recursive: true, force: true });
+        if (hadPrevious)
+            await promises_1.default.rename(previous, destination).catch(() => undefined);
+        throw error;
+    }
+    if (options.open !== false && process.env.FORKIT_AI_FOOTPRINTS_NO_OPEN !== '1') {
+        const launched = (0, node_child_process_1.spawnSync)('/usr/bin/open', [destination], { stdio: 'ignore', shell: false });
+        if (launched.status !== 0)
+            throw new Error('Forkit was installed, but macOS could not open it.');
+    }
+    return destination;
+}
+async function emit(output, filePath) {
+    process.stdout.write(output);
+    if (filePath)
+        await promises_1.default.writeFile(filePath, output, { encoding: 'utf8', flag: 'w' });
+}
+function clipboardCommands(platform) {
+    if (platform === 'darwin')
+        return [{ command: 'pbcopy', args: [] }];
+    if (platform === 'win32')
+        return [{ command: 'clip', args: [] }];
+    return [
+        { command: 'wl-copy', args: [] },
+        { command: 'xclip', args: ['-selection', 'clipboard'] },
+    ];
+}
+function copyToClipboard(value) {
+    for (const invocation of clipboardCommands(process.platform)) {
+        const result = (0, node_child_process_1.spawnSync)(invocation.command, invocation.args, {
+            input: value,
+            encoding: 'utf8',
+            stdio: ['pipe', 'ignore', 'ignore'],
+            shell: false,
+        });
+        if (result.status === 0)
+            return true;
+    }
+    return false;
+}
+async function main(args = process.argv.slice(2)) {
+    let options;
+    try {
+        options = parseArgs(args);
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : 'Invalid arguments'}\n\n${HELP}`);
+        return 2;
+    }
+    if (options.command === 'help') {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    if (options.command === 'version') {
+        process.stdout.write(`${version_1.PRODUCT_VERSION}\n`);
+        return 0;
+    }
+    if (options.command === 'install') {
+        const destination = await installPersistentMacApp();
+        process.stdout.write(`Forkit AI Footprint is installed at ${destination}\nOpen it later from Applications or Spotlight; Terminal is no longer required.\nYour AI activity stays on this device by default. After seeing your results, you can optionally review aggregate measurements for global comparison.\n`);
+        return 0;
+    }
+    if (options.command === 'serve') {
+        const service = await (0, server_1.startAiFootprintsServer)({ port: options.port });
+        process.stdout.write(`Forkit AI Footprints is ready at ${service.url}\nMetadata stays on this device. Press Ctrl+C to stop.\n`);
+        if (process.platform === 'darwin' && process.env.FORKIT_AI_FOOTPRINTS_NO_OPEN !== '1'
+            && process.env.FORKIT_AI_FOOTPRINTS_APP_BUNDLE !== '1') {
+            (0, node_child_process_1.spawnSync)('open', [service.url], { stdio: 'ignore', shell: false });
+        }
+        await new Promise((resolve) => {
+            const stop = () => { void service.close().finally(resolve); };
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+        });
+        return 0;
+    }
+    if (options.command === 'monitor') {
+        const monitor = new monitor_1.ActivityMonitor();
+        await monitor.start();
+        process.stderr.write('Monitoring locally until Ctrl+C. Process IDs and commands are not emitted.\n');
+        await new Promise((resolve) => {
+            const stop = () => resolve();
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+        });
+        const summary = monitor.stop();
+        const rendered = options.json
+            ? `${JSON.stringify(summary, null, 2)}\n`
+            : `Observed ${summary.observed_seconds.toFixed(1)}s · AI active ${summary.active_seconds.toFixed(1)}s · ratio ${summary.activity_ratio === null ? 'unavailable' : `${Math.round(summary.activity_ratio * 100)}%`}\n`;
+        await emit(rendered, options.output);
+        if (options.anonymousPayload) {
+            process.stderr.write('Anonymous preview requires a completed 10-minute GUI session with the exact payload reviewed first. Nothing was uploaded.\n');
+            return 2;
+        }
+        return 0;
+    }
+    if (options.command === 'doctor') {
+        const report = await (0, doctor_1.runDoctor)();
+        const rendered = options.json
+            ? `${JSON.stringify(report, null, 2)}\n`
+            : (0, format_1.formatDoctorReport)(report);
+        await emit(rendered, options.output);
+        return report.ok ? 0 : 1;
+    }
+    if (options.command === 'evaluate') {
+        if (!options.truth) {
+            process.stderr.write('evaluate requires --truth with a local labelled macOS truth file.\n');
+            return 2;
+        }
+        const evaluation = await (0, evaluate_1.evaluateMacosFieldTruthFile)(options.truth);
+        await emit(`${JSON.stringify(evaluation, null, 2)}\n`, options.output);
+        return 0;
+    }
+    if (options.command === 'aggregate') {
+        if (!options.results) {
+            process.stderr.write('aggregate requires --results with a directory of local evaluation JSON files.\n');
+            return 2;
+        }
+        const aggregate = await (0, aggregate_1.aggregateMacosFieldEvaluationDirectory)(options.results);
+        await emit(`${JSON.stringify(aggregate, null, 2)}\n`, options.output);
+        return 0;
+    }
+    if (options.command === 'share-page') {
+        if (!options.output) {
+            process.stderr.write('share-page requires --output with a local HTML file path.\n');
+            return 2;
+        }
+        const report = await (0, census_1.runCensus)({
+            includeRuntimes: options.includeRuntimes,
+            includeFilesystem: options.includeFilesystem,
+            includeAgents: options.includeAgents,
+            includeTools: options.includeTools,
+            includeMcp: options.includeMcp,
+            guess: options.guess,
+            ...(options.modelDirs.length > 0 ? { filesystemRoots: options.modelDirs } : {}),
+        });
+        if (process.env.FORKIT_AI_FOOTPRINTS_DISABLE_JOURNAL !== '1') {
+            await (0, local_device_1.recordLocalScan)({ now: () => new Date(report.generated_at) });
+            report.privacy.local_state_written = true;
+            report.privacy.local_state_scope = 'device-journal-only';
+        }
+        await promises_1.default.writeFile(options.output, (0, share_page_1.renderCensusSharePage)(report), { encoding: 'utf8', flag: 'w' });
+        process.stdout.write('Local aggregate share page written. No data was uploaded.\n');
+        return 0;
+    }
+    const report = await (0, census_1.runCensus)({
+        includeRuntimes: options.includeRuntimes,
+        includeFilesystem: options.includeFilesystem,
+        includeAgents: options.includeAgents,
+        includeTools: options.includeTools,
+        includeMcp: options.includeMcp,
+        guess: options.guess,
+        ...(options.modelDirs.length > 0 ? { filesystemRoots: options.modelDirs } : {}),
+    });
+    if (process.env.FORKIT_AI_FOOTPRINTS_DISABLE_JOURNAL !== '1') {
+        await (0, local_device_1.recordLocalScan)({ now: () => new Date(report.generated_at) });
+        report.privacy.local_state_written = true;
+        report.privacy.local_state_scope = 'device-journal-only';
+    }
+    const rendered = options.json
+        ? `${JSON.stringify(report, null, 2)}\n`
+        : (0, format_1.formatCensusReport)(report, { verbose: options.verbose });
+    await emit(rendered, options.output);
+    if (options.copy && !copyToClipboard(rendered)) {
+        process.stderr.write('Clipboard command unavailable; the result remains printable and can be copied from the terminal.\n');
+    }
+    if (options.anonymousPayload) {
+        process.stderr.write(options.shareConsent
+            ? 'Anonymous contribution was not prepared: a valid 10-minute monitor session and exact payload review are required. Nothing was uploaded.\n'
+            : 'Anonymous contribution was not prepared: separate --consent-share is required. Nothing was uploaded.\n');
+        return 2;
+    }
+    return 0;
+}
+if (require.main === module) {
+    void main().then((code) => {
+        process.exitCode = code;
+    }).catch(() => {
+        process.stderr.write('Forkit AI Footprints failed safely. No raw error details were printed.\n');
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=cli.js.map

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

@@ -0,0 +1,14 @@
+import { PRODUCT_NAME } from './version';
+export interface DoctorCheck {
+    name: string;
+    ok: boolean;
+    detail: string;
+}
+export interface DoctorReport {
+    product: typeof PRODUCT_NAME;
+    version: string;
+    ok: boolean;
+    checks: DoctorCheck[];
+}
+export declare function runDoctor(): Promise<DoctorReport>;
+//# sourceMappingURL=doctor.d.ts.map

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

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const node_fs_1 = __importDefault(require("node:fs"));
+const agents_1 = require("./agents");
+const endpoints_1 = require("./endpoints");
+const filesystem_1 = require("./filesystem");
+const version_1 = require("./version");
+async function runDoctor() {
+    const nodeMajor = Number(process.versions.node.split('.')[0] ?? 0);
+    const supportedNode = [20, 22, 24].includes(nodeMajor);
+    const rawEndpoints = process.env.FORKIT_CENSUS_OPENAI_ENDPOINTS ?? 'http://localhost:8000';
+    const endpointCandidates = rawEndpoints.split(/[\n,]/).map((entry) => entry.trim()).filter(Boolean);
+    const safeEndpoints = (0, endpoints_1.parseLoopbackEndpointList)(rawEndpoints);
+    let processInventoryOk = true;
+    try {
+        await (0, agents_1.listSystemProcesses)();
+    }
+    catch {
+        processInventoryOk = false;
+    }
+    const existingModelRoots = (0, filesystem_1.getDefaultModelRoots)().filter((root) => {
+        try {
+            return node_fs_1.default.statSync(root).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }).length;
+    const checks = [
+        {
+            name: 'operating-system',
+            ok: process.platform === 'darwin',
+            detail: process.platform === 'darwin'
+                ? 'macOS is supported by this release candidate.'
+                : `This release candidate supports macOS only; detected ${process.platform}.`,
+        },
+        {
+            name: 'node-version',
+            ok: supportedNode,
+            detail: supportedNode ? `Node ${nodeMajor} is supported.` : `Node ${nodeMajor} is unsupported; use 20, 22, or 24.`,
+        },
+        {
+            name: 'process-inventory',
+            ok: processInventoryOk,
+            detail: processInventoryOk ? 'Process metadata can be enumerated.' : 'Process metadata cannot be enumerated.',
+        },
+        {
+            name: 'loopback-only-endpoints',
+            ok: safeEndpoints.length === endpointCandidates.length,
+            detail: safeEndpoints.length === endpointCandidates.length
+                ? `${safeEndpoints.length} configured endpoint(s) are loopback-only.`
+                : 'One or more configured endpoints were rejected because Census only allows loopback HTTP(S).',
+        },
+        {
+            name: 'model-roots',
+            ok: true,
+            detail: `${existingModelRoots} known model root(s) currently exist; zero is allowed.`,
+        },
+    ];
+    return {
+        product: version_1.PRODUCT_NAME,
+        version: version_1.PRODUCT_VERSION,
+        ok: checks.every((check) => check.ok),
+        checks,
+    };
+}
+//# sourceMappingURL=doctor.js.map

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

@@ -0,0 +1,8 @@
+export interface SafeEndpoint {
+    url: string;
+    display: string;
+    id: string;
+}
+export declare function parseLoopbackEndpoint(input: string): SafeEndpoint | null;
+export declare function parseLoopbackEndpointList(input: string): SafeEndpoint[];
+//# sourceMappingURL=endpoints.d.ts.map

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLoopbackEndpoint = parseLoopbackEndpoint;
+exports.parseLoopbackEndpointList = parseLoopbackEndpointList;
+const hash_1 = require("./hash");
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
+function parseLoopbackEndpoint(input) {
+    try {
+        const parsed = new URL(String(input || '').trim());
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+            return null;
+        if (parsed.username || parsed.password)
+            return null;
+        if (!LOOPBACK_HOSTS.has(parsed.hostname))
+            return null;
+        parsed.hash = '';
+        parsed.search = '';
+        const displayPath = parsed.pathname === '/' ? '' : parsed.pathname.replace(/\/+$/, '');
+        parsed.pathname = displayPath;
+        const url = parsed.toString().replace(/\/$/, '');
+        const displayHost = parsed.hostname === '::1' ? '[::1]' : parsed.hostname;
+        const display = `${parsed.protocol}//${displayHost}${parsed.port ? `:${parsed.port}` : ''}${displayPath}`;
+        return {
+            url,
+            display,
+            id: (0, hash_1.stableId)('endpoint', display),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseLoopbackEndpointList(input) {
+    const seen = new Set();
+    const endpoints = [];
+    for (const candidate of String(input || '').split(/[\n,]/)) {
+        const endpoint = parseLoopbackEndpoint(candidate);
+        if (!endpoint || seen.has(endpoint.url))
+            continue;
+        seen.add(endpoint.url);
+        endpoints.push(endpoint);
+    }
+    return endpoints;
+}
+//# sourceMappingURL=endpoints.js.map

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

@@ -0,0 +1,44 @@
+import type { CensusReport } from './types';
+export interface MacosFieldTruth {
+    schema_version: '1.0';
+    expected: {
+        agent_signatures: string[];
+        tool_names: string[];
+        online_runtime_names: string[];
+        model_keys: string[];
+        mcp_clients: string[];
+    };
+}
+export interface SurfaceMetrics {
+    actual_count: number;
+    expected_count: number;
+    true_positive: number;
+    false_positive: number;
+    false_negative: number;
+    precision: number | null;
+    recall: number | null;
+}
+export interface MacosFieldEvaluation {
+    evaluation: 'macos-local-labelled-device';
+    schema_version: '1.0';
+    product_version: string;
+    environment: {
+        platform: 'darwin';
+        architecture: string;
+        macos_major: number | null;
+        node_major: number;
+    };
+    metrics: {
+        agents: SurfaceMetrics;
+        tools: SurfaceMetrics;
+        runtimes: SurfaceMetrics;
+        models: SurfaceMetrics;
+        mcp: SurfaceMetrics;
+    };
+    uploaded: false;
+    field_accuracy_claim_allowed: false;
+}
+export declare function detectMacosMajorVersion(): number | null;
+export declare function evaluateMacosFieldTruth(truthInput: unknown, report: CensusReport, macosMajor?: number | null): MacosFieldEvaluation;
+export declare function evaluateMacosFieldTruthFile(filePath: string): Promise<MacosFieldEvaluation>;
+//# sourceMappingURL=evaluate.d.ts.map