forkit-ai-footprints 0.2.0

package/dist/sharing.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINIMUM_COMPARISON_SECONDS = void 0;
+exports.buildAnonymousAiFootprintPreview = buildAnonymousAiFootprintPreview;
+exports.authorizeAnonymousAiFootprintContribution = authorizeAnonymousAiFootprintContribution;
+const node_child_process_1 = require("node:child_process");
+exports.MINIMUM_COMPARISON_SECONDS = 600;
+function macosMajorVersion() {
+    try {
+        const productVersion = (0, node_child_process_1.execFileSync)('/usr/bin/sw_vers', ['-productVersion'], {
+            encoding: 'utf8',
+            timeout: 2_000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        const major = Number(productVersion.split('.')[0]);
+        return Number.isInteger(major) && major > 0 ? major : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function buildAnonymousAiFootprintPreview(report, monitor, options = {}) {
+    if (report.system.platform !== 'darwin')
+        throw new Error('ANONYMOUS_FOOTPRINT_MACOS_REQUIRED');
+    if (!report.summary.storage_complete)
+        throw new Error('ANONYMOUS_FOOTPRINT_STORAGE_INCOMPLETE');
+    if (monitor.observed_seconds < exports.MINIMUM_COMPARISON_SECONDS)
+        throw new Error('ANONYMOUS_FOOTPRINT_MINIMUM_OBSERVATION_REQUIRED');
+    if (monitor.active_seconds < 0 || monitor.active_seconds > monitor.observed_seconds)
+        throw new Error('ANONYMOUS_FOOTPRINT_INVALID_ACTIVITY_DURATION');
+    const validSeconds = Math.floor(monitor.observed_seconds);
+    const activeSeconds = Math.min(validSeconds, Math.floor(monitor.active_seconds));
+    const workingProducts = monitor.products.filter((product) => product.active_seconds > 0);
+    return {
+        schema_version: '2.0',
+        observation: {
+            valid_seconds: validSeconds,
+            ai_active_seconds: activeSeconds,
+            activity_ratio: validSeconds === 0 ? 0 : Math.round((activeSeconds / validSeconds) * 1000) / 1000,
+        },
+        counts: {
+            supported_apps_observed_working: workingProducts.length,
+            supported_app_categories: [...new Set(workingProducts.map((product) => product.kind))].sort(),
+            local_models_discovered: report.summary.model_count,
+            local_models_loaded: report.summary.confirmed_running_model_count,
+            verified_local_runtimes_available: report.summary.available_runtime_count,
+        },
+        model_storage_bytes: report.summary.storage_bytes,
+        system: {
+            platform: 'darwin',
+            architecture: report.system.architecture,
+            os_major: options.osMajor ?? macosMajorVersion(),
+        },
+        versions: {
+            scanner: report.product_version,
+            node_major: report.system.node_major,
+            monitor_schema: monitor.schema_version,
+        },
+    };
+}
+/** Consent is separate from local preview construction. This never uploads. */
+function authorizeAnonymousAiFootprintContribution(payload, consent) {
+    if (!consent)
+        throw new Error('ANONYMOUS_FOOTPRINT_CONSENT_REQUIRED');
+    return payload;
+}
+//# sourceMappingURL=sharing.js.map

package/dist/tools.d.ts

@@ -0,0 +1,9 @@
+import type { CensusAgent, CensusTool } from './types';
+export interface ToolDetectionOptions {
+    homeDir: string;
+    env: NodeJS.ProcessEnv;
+    platform: NodeJS.Platform;
+    agents: CensusAgent[];
+}
+export declare function detectAiTools(options: ToolDetectionOptions): Promise<CensusTool[]>;
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAiTools = detectAiTools;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const hash_1 = require("./hash");
+async function exists(targetPath) {
+    try {
+        await promises_1.default.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function executableCandidates(command, platform, env) {
+    if (platform !== 'win32')
+        return [command];
+    const extensions = String(env.PATHEXT || '.EXE;.CMD;.BAT')
+        .split(';')
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean);
+    return [command, ...extensions.map((extension) => `${command}${extension}`)];
+}
+async function commandExists(command, platform, env) {
+    const directories = String(env.PATH || env.Path || env.path || '')
+        .split(node_path_1.default.delimiter)
+        .filter(Boolean)
+        .slice(0, 256);
+    const candidates = executableCandidates(command, platform, env);
+    for (const directory of directories) {
+        for (const candidate of candidates) {
+            if (await exists(node_path_1.default.join(directory, candidate)))
+                return true;
+        }
+    }
+    return false;
+}
+function definitions(homeDir) {
+    return [
+        { name: 'Claude Code', signatures: ['claude'], commands: ['claude'], configPaths: [node_path_1.default.join(homeDir, '.claude')] },
+        { name: 'Codex', signatures: ['codex'], commands: ['codex'], configPaths: [node_path_1.default.join(homeDir, '.codex')], appPaths: ['/Applications/Codex.app', node_path_1.default.join(homeDir, 'Applications', 'Codex.app')] },
+        { name: 'Cursor', signatures: ['cursor'], commands: ['cursor'], configPaths: [node_path_1.default.join(homeDir, '.cursor')], appPaths: ['/Applications/Cursor.app', node_path_1.default.join(homeDir, 'Applications', 'Cursor.app')] },
+        { name: 'Windsurf', signatures: ['windsurf'], commands: ['windsurf'], configPaths: [node_path_1.default.join(homeDir, '.codeium', 'windsurf')], appPaths: ['/Applications/Windsurf.app', node_path_1.default.join(homeDir, 'Applications', 'Windsurf.app')] },
+        { name: 'Gemini CLI', signatures: ['gemini-cli'], commands: ['gemini'], configPaths: [node_path_1.default.join(homeDir, '.gemini')] },
+        { name: 'GitHub Copilot', signatures: ['github-copilot'], commands: [], configPaths: [] },
+        { name: 'OpenCode', signatures: ['opencode'], commands: ['opencode'], configPaths: [node_path_1.default.join(homeDir, '.config', 'opencode')] },
+        { name: 'OpenClaw', signatures: ['openclaw'], commands: ['openclaw'], configPaths: [node_path_1.default.join(homeDir, '.openclaw')] },
+        { name: 'Jan', signatures: [], commands: ['jan'], configPaths: [node_path_1.default.join(homeDir, 'Library', 'Application Support', 'Jan')], appPaths: ['/Applications/Jan.app', node_path_1.default.join(homeDir, 'Applications', 'Jan.app')] },
+        { name: 'LM Studio', signatures: [], commands: ['lms'], configPaths: [node_path_1.default.join(homeDir, '.lmstudio')], appPaths: ['/Applications/LM Studio.app', node_path_1.default.join(homeDir, 'Applications', 'LM Studio.app')] },
+        { name: 'Zed', signatures: [], commands: ['zed'], configPaths: [node_path_1.default.join(homeDir, '.zed')], appPaths: ['/Applications/Zed.app', node_path_1.default.join(homeDir, 'Applications', 'Zed.app')] },
+    ];
+}
+async function hasCopilotExtension(homeDir) {
+    const roots = [
+        node_path_1.default.join(homeDir, '.vscode', 'extensions'),
+        node_path_1.default.join(homeDir, '.vscode-insiders', 'extensions'),
+    ];
+    for (const root of roots) {
+        try {
+            const names = await promises_1.default.readdir(root);
+            if (names.some((name) => /^github\.copilot(?:-chat)?(?:-|$)/i.test(name)))
+                return true;
+        }
+        catch {
+            // Missing or unreadable extension roots are normal.
+        }
+    }
+    return false;
+}
+async function detectAiTools(options) {
+    const tools = [];
+    for (const definition of definitions(options.homeDir)) {
+        const detectorTypes = new Set();
+        const matchingAgents = options.agents.filter((agent) => definition.signatures.includes(agent.signature));
+        if (matchingAgents.length > 0)
+            detectorTypes.add('process');
+        const commandInstalled = (await Promise.all(definition.commands.map((command) => commandExists(command, options.platform, options.env)))).some(Boolean);
+        const appInstalled = options.platform === 'darwin'
+            && (await Promise.all((definition.appPaths ?? []).map((targetPath) => exists(targetPath)))).some(Boolean);
+        if (commandInstalled || appInstalled) {
+            detectorTypes.add('executable');
+        }
+        const configured = definition.name === 'GitHub Copilot'
+            ? await hasCopilotExtension(options.homeDir)
+            : (await Promise.all(definition.configPaths.map((targetPath) => exists(targetPath)))).some(Boolean);
+        if (configured)
+            detectorTypes.add('config');
+        if (detectorTypes.size === 0)
+            continue;
+        const instanceCount = matchingAgents.reduce((total, agent) => total + agent.instance_count, 0);
+        tools.push({
+            tool_id: (0, hash_1.stableId)('tool', definition.name),
+            name: definition.name,
+            evidence_status: detectorTypes.has('process') ? 'online' : 'configured',
+            confidence: detectorTypes.has('process') || detectorTypes.size >= 2 ? 'high' : 'medium',
+            detector_types: [...detectorTypes].sort(),
+            instance_count: instanceCount,
+        });
+    }
+    return tools.sort((left, right) => left.name.localeCompare(right.name));
+}
+//# sourceMappingURL=tools.js.map

package/dist/types.d.ts

@@ -0,0 +1,166 @@
+export type Confidence = 'high' | 'medium' | 'low';
+export type EvidenceStatus = 'discovered' | 'configured' | 'online' | 'confirmed-running';
+export type RuntimeKind = 'ollama' | 'lmstudio' | 'openai-compatible' | 'filesystem';
+export type RuntimeStatus = 'available' | 'unavailable' | 'inventory-only';
+export interface CensusRuntime {
+    runtime_id: string;
+    name: RuntimeKind;
+    status: RuntimeStatus;
+    endpoint: string | null;
+    model_count: number;
+    observed_at: string;
+    error_code: string | null;
+    evidence_status: 'configured' | 'online' | 'unavailable';
+}
+export interface CensusModel {
+    model_id: string;
+    name: string;
+    runtime: RuntimeKind;
+    identity_kind: 'content-sha256' | 'provider-id' | 'metadata-sha256';
+    identity: string;
+    size_bytes: number | null;
+    modified_at: string | null;
+    quantization: string | null;
+    architecture: string | null;
+    parameter_size: string | null;
+    source: 'runtime-api' | 'filesystem';
+    location_hint: string | null;
+    confidence: Confidence;
+    evidence_status: 'discovered' | 'confirmed-running';
+}
+export type AgentKind = 'coding-agent' | 'ide-agent' | 'agent-framework' | 'mcp-server';
+export interface CensusAgent {
+    agent_id: string;
+    name: string;
+    signature: string;
+    kind: AgentKind;
+    confidence: Confidence;
+    instance_count: number;
+    executable_names: string[];
+    evidence_hashes: string[];
+    detection_reason: string;
+    evidence_status: 'online';
+    resource_snapshot: {
+        cpu_percent: number | null;
+        memory_percent: number | null;
+        measurement: 'point-in-time-process-metadata';
+    };
+}
+export interface CensusTool {
+    tool_id: string;
+    name: string;
+    evidence_status: 'configured' | 'online';
+    confidence: Confidence;
+    detector_types: Array<'config' | 'executable' | 'process'>;
+    instance_count: number;
+}
+export interface CensusMcpConfig {
+    client: string;
+    evidence_status: 'configured';
+    confidence: Confidence;
+    server_count: number;
+}
+export interface CensusWarning {
+    code: string;
+    message: string;
+    scope: 'runtime' | 'model' | 'agent' | 'privacy' | 'system';
+}
+export interface CensusSummary {
+    runtime_count: number;
+    available_runtime_count: number;
+    model_count: number;
+    agent_product_count: number;
+    agent_process_count: number;
+    agent_cpu_percent: number | null;
+    agent_memory_percent: number | null;
+    tool_count: number;
+    mcp_config_count: number;
+    confirmed_running_model_count: number;
+    storage_bytes: number;
+    storage_file_count: number;
+    storage_complete: boolean;
+    storage_measurement: 'recognized-logical-file-bytes';
+    warning_count: number;
+}
+export interface CensusReport {
+    schema_version: '1.3';
+    product: 'forkit-ai-footprints';
+    product_version: string;
+    census_id: string;
+    generated_at: string;
+    system: {
+        platform: NodeJS.Platform;
+        architecture: string;
+        node_major: number;
+    };
+    privacy: {
+        mode: 'metadata-only';
+        raw_commands_retained: false;
+        model_file_contents_read: false;
+        config_values_emitted: false;
+        sensitive_content_retained: false;
+        remote_endpoints_allowed: false;
+        external_requests_made: 0;
+        backend_contacted: false;
+        account_read: false;
+        local_state_written: boolean;
+        local_state_scope: 'none' | 'device-journal-only';
+    };
+    summary: CensusSummary;
+    runtimes: CensusRuntime[];
+    models: CensusModel[];
+    agents: CensusAgent[];
+    tools: CensusTool[];
+    mcp_configs: CensusMcpConfig[];
+    guess: {
+        provided: number | null;
+        discovered: number;
+        difference: number | null;
+    };
+    warnings: CensusWarning[];
+}
+export interface RuntimeScanResult {
+    runtime: CensusRuntime;
+    models: CensusModel[];
+    warnings: CensusWarning[];
+    storage?: {
+        logical_bytes: number;
+        recognized_file_count: number;
+        complete: boolean;
+        measurement: 'recognized-logical-file-bytes';
+    };
+}
+export interface RuntimeProvider {
+    readonly name: RuntimeKind;
+    scan(observedAt: string): Promise<RuntimeScanResult>;
+}
+export interface ProcessEntry {
+    pid: number;
+    ppid?: number;
+    name?: string;
+    cmd?: string;
+    cpu_percent?: number;
+    memory_percent?: number;
+    /** Internal resident memory from the operating system. Never emitted in a Census report. */
+    rss_bytes?: number;
+    /** Internal cumulative process CPU time. Never emitted in a Census report. */
+    cpu_time_ms?: number;
+}
+export interface CensusOptions {
+    includeRuntimes?: boolean;
+    includeFilesystem?: boolean;
+    includeAgents?: boolean;
+    includeTools?: boolean;
+    includeMcp?: boolean;
+    filesystemRoots?: string[];
+    processEntries?: ProcessEntry[];
+    providers?: RuntimeProvider[];
+    now?: () => Date;
+    guess?: number | null;
+    homeDir?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    architecture?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/version.d.ts

@@ -0,0 +1,4 @@
+export declare const PRODUCT_NAME: "forkit-ai-footprints";
+export declare const PRODUCT_VERSION: string;
+export declare const SCHEMA_VERSION: "1.3";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_VERSION = exports.PRODUCT_VERSION = exports.PRODUCT_NAME = void 0;
+exports.PRODUCT_NAME = 'forkit-ai-footprints';
+const package_json_1 = __importDefault(require("../package.json"));
+// package.json is the only product-version source. npm, the CLI, native
+// bundles, GitHub release tags, and package-manager metadata must derive from it.
+exports.PRODUCT_VERSION = package_json_1.default.version;
+exports.SCHEMA_VERSION = '1.3';
+//# sourceMappingURL=version.js.map

package/docs/GLOBAL_DISTRIBUTION.md

@@ -0,0 +1,79 @@
+# Forkit AI Footprints global distribution
+
+Status: v0.2.0 npm-first Apple Silicon macOS release approved.
+
+## Goal
+
+Offer a free, professional installation path to Mac users anywhere in the
+world, while ensuring npm, Homebrew, GitHub Releases, the future Mac installer,
+and the website can never silently recommend different product versions.
+
+## One release identity
+
+`package.json` is the only version source. The CLI imports it at build time and
+the native Mac package builder reads it directly. `npm run release:check`
+rejects a different lockfile version, CLI version source, native package version,
+or documented status version.
+
+`npm run release:manifest` generates the candidate release manifest under
+`artifacts/release/`. The generated manifest is metadata only; generating it
+does not publish anything.
+
+## Global channels
+
+| Channel | Audience | Cost to users | Current state |
+|---|---|---:|---|
+| GitHub Release | canonical immutable source/release identity | Free | v0.2.0 release |
+| npm public registry | primary Apple Silicon bootstrap; installs a persistent app in `~/Applications` | Free | v0.2.0 |
+| Homebrew tap | optional future package-manager channel | Free | Tap not created |
+| Signed `.pkg` | future click installation | Free to users | Blocked on paid Apple identity and notarization |
+
+Homebrew and npm are not tied to the founder's Mac. They are global registries.
+The npm command is a one-time bootstrap: it copies a self-contained GUI app into
+the current user's Applications folder and opens it. Later use is through
+Applications, Spotlight, Dock, or the Forkit menu-bar icon without Terminal.
+The current product support claim is still macOS on Apple Silicon until broader
+field validation exists.
+
+## Release order
+
+1. Bump `package.json` and `package-lock.json` together.
+2. Run tests, package smoke, real-Mac validation, and `npm run release:check`.
+3. Build the npm tarball and candidate release manifest on a clean hosted runner.
+4. Create one draft GitHub Release for `v<version>` and attach the tarball,
+   manifest, checksum, SBOM, and provenance evidence.
+5. After founder approval, publish the exact tested package. A brand-new npm
+   package requires one interactive first publication before its trusted
+   publisher can be configured; all later releases use GitHub Actions OIDC.
+6. Update the Homebrew tap from the immutable release URL and SHA-256.
+7. Mark a channel `available` in the release manifest only after its registry
+   resolves to the same version and checksum.
+8. Let Forkit.dev read the verified manifest and recommend the simplest
+   available channel. If coherence fails, the website must show no install CTA.
+
+The release automation should run only for an approved release tag or a manual
+release action—not for normal commits—so it does not waste GitHub Actions runs.
+
+## Hugging Face cache boundary
+
+AI Footprints supports the official Hub file cache at
+`~/.cache/huggingface/hub`, `$HF_HOME/hub`, `$HF_HUB_CACHE`, and the
+XDG-configured equivalent. It recognizes `models--<org>--<repo>` directories
+and follows snapshot links while deduplicating the same physical blob across
+revisions.
+
+`HF_XET_CACHE` is deliberately excluded. It contains transport chunks that can
+be shared across files and would double-count model storage. Datasets, Spaces,
+assets, incomplete downloads, and unreferenced extensionless blobs are also not
+reported as model storage. The reported value is therefore exact for recognized
+model artifacts inside supported roots, not the total size of every Hugging
+Face cache directory.
+
+## Brand assets
+
+The website's `/brand/icon-dark.svg` and `/brand/icon-light.svg` are byte-for-byte
+copies of the supplied `Logo_Forkit/logo_Only/color_Dark/color_Dark.svg` and
+`Logo_Forkit/logo_Only/color_Light/color_Light.svg`. The dark-outline mark is for
+light surfaces; the light-outline mark is for dark surfaces. The product name
+remains live text so the older “Forkit Dev” wordmark is not incorrectly presented
+as the AI Footprints product name.

package/docs/MACOS_ACCURACY_GATE.md

@@ -0,0 +1,140 @@
+# macOS Accuracy and Release Gate
+
+Forkit AI Footprints must not claim a global accuracy percentage or broaden its
+platform support until this gate is reviewed. Passing local tests is necessary
+but is not field accuracy.
+
+## Current supported claim
+
+- operating system: macOS only;
+- current real-device evidence: one Apple Silicon Mac;
+- Intel Mac: not yet field validated;
+- distribution: public npm bootstrap for Apple Silicon macOS;
+- network: loopback runtime APIs only, with no uploader or Forkit.dev client.
+
+## Evidence classes
+
+- `online`: a supported runtime API responded, or a running agent has exact
+  executable, explicit module, or explicit package-runner evidence;
+- `configured`: installation/configuration metadata exists, without claiming a
+  process is active;
+- `confirmed-running`: Ollama `/api/ps` reported the model as loaded;
+- `discovered`: inventory evidence exists without proof of active execution.
+
+Filesystem findings remain best-effort and low confidence. Process instance
+counts are not independent-agent or user-session counts.
+
+## Local labelled evaluation
+
+Each tester creates a local JSON truth file after manually checking their Mac:
+
+```json
+{
+  "schema_version": "1.0",
+  "expected": {
+    "agent_signatures": ["codex"],
+    "tool_names": ["Codex"],
+    "online_runtime_names": ["ollama"],
+    "model_keys": ["ollama:example-model:latest"],
+    "mcp_clients": ["Codex"]
+  }
+}
+```
+
+Run:
+
+```bash
+npm run evaluate:macos -- /absolute/path/to/local-truth.json
+```
+
+Testers using the packed or installed CLI run the equivalent public command:
+
+```bash
+forkit-census evaluate --truth /absolute/path/to/local-truth.json
+```
+
+The result contains aggregate counts and metrics only. It does not contain the
+truth-file item names and is not uploaded.
+
+Each tester reviews the result and may then explicitly share that result file,
+but never the truth file. The coordinator aggregates a directory of reviewed
+results locally:
+
+```bash
+forkit-census aggregate --results /absolute/path/to/macos-field-results
+```
+
+The aggregate reports CPU, macOS-major, and Node-major coverage plus Wilson 95%
+confidence intervals. It cannot enable an accuracy claim automatically. The
+coordinator must separately verify one submission per independently labelled
+Mac because the privacy-preserving output contains no persistent device ID.
+Different Census versions must not be pooled.
+
+The evaluator emits aggregate counts and per-surface precision/recall locally.
+It does not emit item names, raw commands, full paths, credentials, or upload
+anything. Truth files must not be committed because model names can be private.
+
+## Public-release minimums
+
+1. At least 100 manually labelled Macs across the latest three supported macOS
+   major releases and representative Apple Silicon generations.
+2. Intel Mac must remain explicitly unsupported unless separately represented
+   and passing.
+3. At least 300 confirmed/online positive findings with no unreviewed false
+   positive if a 99% precision claim is planned. Report a 95% confidence
+   interval, not only the point estimate.
+4. The lower 95% confidence bound for confirmed/online precision must be at
+   least 99% per surface that uses that claim.
+5. The lower 95% confidence bound for recall within the declared supported
+   catalog must be at least 90% per surface.
+6. Zero external scan requests, zero sensitive report leaks, and zero registry,
+   Passport, Mint, Runtime_C2, or production writes.
+7. Repeated unchanged-device item sets must be at least 99% stable; time and
+   process-instance counts are excluded from this comparison.
+8. Package install, tests, doctor, and isolated tarball smoke must pass on Node
+   20, 22, and 24 on hosted macOS runners and on real Macs.
+
+The tarball smoke is a separate release gate and must run before `npm publish`;
+it is intentionally not nested inside npm's publication lifecycle.
+
+These are release gates, not current achievements. No public accuracy claim is
+allowed until an independently reviewed aggregate evaluation satisfies them.
+
+## Accuracy interpretation
+
+Different numbers have different meanings; there is no honest single accuracy
+percentage for the whole product.
+
+- **Known agents/tools:** the curated process corpus is a conformance test, not
+  field prevalence. The release target is a lower 95% precision bound of 99%
+  and a lower 95% supported-catalog recall bound of 90% after the field minimum.
+- **Supported runtimes and loaded models:** a successful loopback API response
+  is strong current-state evidence. Unsupported/custom runtimes remain outside
+  recall and must not be described as absent AI.
+- **Model inventory:** file metadata and runtime records are exact for evidence
+  the scanner recognizes, but total recall across every possible model format
+  and directory is unknown until representative field labelling.
+- **Model storage:** the byte sum is exact for recognized files whose metadata
+  can be read. It is not total AI disk use when a format or location is outside
+  the supported catalog.
+- **Agent CPU/memory:** the values are operating-system samples for strongly
+  detected processes. They are not exclusive task attribution and receive no
+  per-task accuracy percentage in this release.
+- **Verified global installations:** App Attest plus replay/risk controls can
+  strongly establish a genuine supported app installation, but this is an
+  integrity result rather than detector precision. It cannot prove that every
+  local artifact is meaningful or prevent all deliberate local environment
+  manipulation.
+
+The practical public target is therefore **≥99% precision and ≥90% recall
+within the explicitly supported catalog**, with Wilson lower bounds satisfying
+the release rules above. The current evidence does not yet authorize those
+figures as achieved accuracy.
+
+## Controlled CI is not field evidence
+
+The labelled compatibility workflow may run tests and privacy/stability checks
+on GitHub-hosted Apple Silicon and Intel macOS runners. Those machines improve
+OS and architecture compatibility evidence, but they do not contain a human's
+independently established inventory truth and must never be counted toward the
+100-Mac field minimum.