kibi-cli 0.16.1 → 0.18.1

package/dist/public/distribution-parity.d.ts

@@ -0,0 +1,90 @@
+export declare const DISTRIBUTION_PARITY_VERSION: "kibi.distribution-parity.v1";
+export declare const REQUIREMENT_COMPILER_CAPABILITIES: readonly ["semantic_inventory", "contradiction_witnesses", "conservative_proof", "repair_plan", "verification_receipts", "telemetry_acceptance"];
+export type RequirementCompilerCapability = (typeof REQUIREMENT_COMPILER_CAPABILITIES)[number];
+export type DistributionRuntimeKind = "source_checkout" | "packed_artifact" | "project_resolved";
+export type DistributionSurface = "cli" | "mcp";
+export type CapabilityState = "supported" | "unsupported" | "failed";
+export interface DistributionRuntimeProvenance {
+    readonly status: "resolved" | "unresolved";
+    readonly executable: string;
+    readonly entrypoint?: string;
+    readonly packageRoot?: string;
+    readonly version?: string;
+    readonly evidence: "executable_resolution" | "entrypoint_resolution";
+    readonly detail?: string;
+}
+export interface DistributionRuntime {
+    readonly id: string;
+    readonly kind: DistributionRuntimeKind;
+    readonly surface: DistributionSurface;
+    readonly project?: string;
+    readonly provenance: DistributionRuntimeProvenance;
+    readonly actions?: Partial<Record<RequirementCompilerCapability, DistributionParityAction>>;
+}
+export interface DistributionParityAction {
+    readonly kind: "upgrade" | "compatibility";
+    readonly detail: string;
+}
+export interface DistributionCapabilityResult {
+    readonly state: CapabilityState;
+    readonly outcome?: unknown;
+    readonly diagnosticIds?: readonly string[];
+    readonly detail?: string;
+}
+export interface DistributionRuntimeAdapter {
+    readonly runtime: DistributionRuntime;
+    readonly execute: (capability: RequirementCompilerCapability) => Promise<DistributionCapabilityResult>;
+}
+export interface DistributionParityObservation extends DistributionCapabilityResult {
+    readonly runtimeId: string;
+    readonly capability: RequirementCompilerCapability;
+}
+export type DistributionComparison = "match" | "diverged" | "unsupported" | "failed" | "not_compared";
+export interface DistributionParityRow {
+    readonly runtimeId: string;
+    readonly kind: DistributionRuntimeKind;
+    readonly surface: DistributionSurface;
+    readonly project?: string;
+    readonly capability: RequirementCompilerCapability;
+    readonly state: CapabilityState | "missing";
+    readonly comparison: DistributionComparison;
+    readonly referenceRuntimeId?: string;
+    readonly normalizedOutcome?: unknown;
+    readonly diagnosticIds: readonly string[];
+    readonly action?: DistributionParityAction;
+    readonly detail?: string;
+}
+export type DistributionParityIssueCode = "duplicate_runtime_id" | "missing_current_runtime" | "unresolved_runtime_provenance" | "missing_capability_observation" | "duplicate_capability_observation" | "current_capability_unsupported" | "capability_execution_failed" | "source_packed_mismatch" | "project_divergence_without_action";
+export interface DistributionParityIssue {
+    readonly code: DistributionParityIssueCode;
+    readonly runtimeId?: string;
+    readonly surface?: DistributionSurface;
+    readonly capability?: RequirementCompilerCapability;
+    readonly detail: string;
+}
+export interface DistributionParityReport {
+    readonly version: typeof DISTRIBUTION_PARITY_VERSION;
+    readonly status: "passed" | "failed";
+    readonly capabilities: readonly RequirementCompilerCapability[];
+    readonly runtimes: readonly DistributionRuntime[];
+    readonly rows: readonly DistributionParityRow[];
+    readonly issues: readonly DistributionParityIssue[];
+    readonly summary: {
+        readonly runtimeCount: number;
+        readonly observationCount: number;
+        readonly matchCount: number;
+        readonly divergenceCount: number;
+        readonly unsupportedCount: number;
+        readonly failedCount: number;
+        readonly actionCount: number;
+    };
+}
+export interface DistributionParityOptions {
+    readonly workspaceRoots?: readonly string[];
+    readonly volatileKeys?: ReadonlySet<string>;
+}
+export declare function resolveDistributionRuntimeProvenance(executable: string): DistributionRuntimeProvenance;
+export declare function normalizeDistributionParityValue(value: unknown, options?: DistributionParityOptions): unknown;
+export declare function buildDistributionParityReport(runtimes: readonly DistributionRuntime[], observations: readonly DistributionParityObservation[], options?: DistributionParityOptions): DistributionParityReport;
+export declare function runDistributionParityMatrix(adapters: readonly DistributionRuntimeAdapter[], options?: DistributionParityOptions): Promise<DistributionParityReport>;
+//# sourceMappingURL=distribution-parity.d.ts.map

package/dist/public/distribution-parity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distribution-parity.d.ts","sourceRoot":"","sources":["../../src/public/distribution-parity.ts"],"names":[],"mappings":"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"}

package/dist/public/distribution-parity.js

@@ -0,0 +1,367 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+*/
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+export const DISTRIBUTION_PARITY_VERSION = "kibi.distribution-parity.v1";
+export const REQUIREMENT_COMPILER_CAPABILITIES = [
+    "semantic_inventory",
+    "contradiction_witnesses",
+    "conservative_proof",
+    "repair_plan",
+    "verification_receipts",
+    "telemetry_acceptance",
+];
+const DEFAULT_VOLATILE_KEYS = new Set([
+    "_diagnostic_telemetry",
+    "active_branch",
+    "artifact_digest",
+    "branch",
+    "branchName",
+    "code_snapshot",
+    "created_at",
+    "createdAt",
+    "elapsedMs",
+    "environment_hash",
+    "finished_at",
+    "finishedAt",
+    "pid",
+    "planId",
+    "prologPid",
+    "receipt_id",
+    "request_id",
+    "requestId",
+    "snapshot_id",
+    "snapshotId",
+    "started_at",
+    "startedAt",
+    "timestamp",
+    "updated_at",
+    "updatedAt",
+    "usageLogLineNumber",
+    "verificationSnapshot",
+]);
+function nearestPackageInfo(entrypoint) {
+    let current = path.dirname(entrypoint);
+    while (true) {
+        const manifestPath = path.join(current, "package.json");
+        if (existsSync(manifestPath)) {
+            try {
+                const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+                return {
+                    packageRoot: current,
+                    ...(manifest.version === undefined
+                        ? {}
+                        : { version: manifest.version }),
+                };
+            }
+            catch {
+                return { packageRoot: current };
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return {};
+        current = parent;
+    }
+}
+function declaredEntrypoint(contents) {
+    const shimTarget = contents.match(/^# cmd-shim-target=(.+)$/m)?.[1]?.trim();
+    if (shimTarget)
+        return shimTarget;
+    const absoluteImport = contents.match(/\bfrom\s+["'](\/(?:[^"']+))["']/)?.[1];
+    return absoluteImport;
+}
+// implements REQ-kibi-distribution-parity-matrix
+export function resolveDistributionRuntimeProvenance(executable) {
+    const requested = path.resolve(executable);
+    if (!existsSync(requested)) {
+        return {
+            status: "unresolved",
+            executable: requested,
+            evidence: "executable_resolution",
+            detail: `Executable does not exist: ${requested}`,
+        };
+    }
+    try {
+        const resolvedExecutable = realpathSync(requested);
+        const contents = readFileSync(resolvedExecutable, "utf8");
+        const declared = declaredEntrypoint(contents);
+        const entrypoint = declared
+            ? realpathSync(path.resolve(path.dirname(resolvedExecutable), declared))
+            : resolvedExecutable;
+        const packageInfo = nearestPackageInfo(entrypoint);
+        return {
+            status: "resolved",
+            executable: resolvedExecutable,
+            entrypoint,
+            ...packageInfo,
+            evidence: entrypoint === resolvedExecutable
+                ? "executable_resolution"
+                : "entrypoint_resolution",
+        };
+    }
+    catch (error) {
+        return {
+            status: "unresolved",
+            executable: requested,
+            evidence: "executable_resolution",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function normalizeString(value, roots) {
+    let normalized = value;
+    for (const root of [...roots].sort((left, right) => right.length - left.length)) {
+        normalized = normalized.replaceAll(root, "<workspace>");
+    }
+    return normalized
+        .replaceAll(/[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/gi, "<uuid>")
+        .replaceAll(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\b/g, "<timestamp>");
+}
+// implements REQ-kibi-distribution-parity-matrix
+export function normalizeDistributionParityValue(value, options = {}) {
+    if (typeof value === "string") {
+        return normalizeString(value, options.workspaceRoots ?? []);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeDistributionParityValue(entry, options));
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    const volatileKeys = options.volatileKeys ?? DEFAULT_VOLATILE_KEYS;
+    const normalized = {};
+    for (const key of Object.keys(value).sort()) {
+        if (volatileKeys.has(key))
+            continue;
+        normalized[key] = normalizeDistributionParityValue(value[key], options);
+    }
+    return normalized;
+}
+function semanticFingerprint(value) {
+    return JSON.stringify(value);
+}
+function sortedUnique(values) {
+    return [...new Set(values ?? [])].sort((left, right) => left.localeCompare(right));
+}
+function currentRuntime(runtimes, kind, surface) {
+    return runtimes.find((runtime) => runtime.kind === kind && runtime.surface === surface);
+}
+function observationKey(runtimeId, capability) {
+    return `${runtimeId}\0${capability}`;
+}
+function compareObservation(observation, reference, normalized, normalizedReference) {
+    if (observation.state === "failed")
+        return "failed";
+    if (observation.state === "unsupported")
+        return "unsupported";
+    if (!reference || reference.state !== "supported")
+        return "not_compared";
+    return semanticFingerprint(normalized) ===
+        semanticFingerprint(normalizedReference)
+        ? "match"
+        : "diverged";
+}
+// implements REQ-kibi-distribution-parity-matrix
+export function buildDistributionParityReport(runtimes, observations, options = {}) {
+    const issues = [];
+    const runtimeIds = new Set();
+    for (const runtime of runtimes) {
+        if (runtimeIds.has(runtime.id)) {
+            issues.push({
+                code: "duplicate_runtime_id",
+                runtimeId: runtime.id,
+                surface: runtime.surface,
+                detail: `Runtime id ${runtime.id} is declared more than once.`,
+            });
+        }
+        runtimeIds.add(runtime.id);
+        if (runtime.provenance.status === "unresolved") {
+            issues.push({
+                code: "unresolved_runtime_provenance",
+                runtimeId: runtime.id,
+                surface: runtime.surface,
+                detail: runtime.provenance.detail ??
+                    `Runtime ${runtime.id} has no executable resolution evidence.`,
+            });
+        }
+    }
+    for (const surface of ["cli", "mcp"]) {
+        for (const kind of ["source_checkout", "packed_artifact"]) {
+            if (!currentRuntime(runtimes, kind, surface)) {
+                issues.push({
+                    code: "missing_current_runtime",
+                    surface,
+                    detail: `Missing ${kind} runtime for ${surface}.`,
+                });
+            }
+        }
+    }
+    const indexed = new Map();
+    for (const observation of observations) {
+        const key = observationKey(observation.runtimeId, observation.capability);
+        if (indexed.has(key)) {
+            issues.push({
+                code: "duplicate_capability_observation",
+                runtimeId: observation.runtimeId,
+                capability: observation.capability,
+                detail: `Capability ${observation.capability} was observed more than once for ${observation.runtimeId}.`,
+            });
+            continue;
+        }
+        indexed.set(key, observation);
+    }
+    const rows = [];
+    for (const runtime of [...runtimes].sort((left, right) => left.id.localeCompare(right.id))) {
+        const source = currentRuntime(runtimes, "source_checkout", runtime.surface);
+        for (const capability of REQUIREMENT_COMPILER_CAPABILITIES) {
+            const observation = indexed.get(observationKey(runtime.id, capability));
+            const reference = source
+                ? indexed.get(observationKey(source.id, capability))
+                : undefined;
+            const action = runtime.actions?.[capability];
+            if (!observation) {
+                issues.push({
+                    code: "missing_capability_observation",
+                    runtimeId: runtime.id,
+                    surface: runtime.surface,
+                    capability,
+                    detail: `Runtime ${runtime.id} has no ${capability} observation.`,
+                });
+                rows.push({
+                    runtimeId: runtime.id,
+                    kind: runtime.kind,
+                    surface: runtime.surface,
+                    ...(runtime.project === undefined
+                        ? {}
+                        : { project: runtime.project }),
+                    capability,
+                    state: "missing",
+                    comparison: "not_compared",
+                    ...(source === undefined ? {} : { referenceRuntimeId: source.id }),
+                    diagnosticIds: [],
+                    ...(action === undefined ? {} : { action }),
+                });
+                continue;
+            }
+            const normalized = normalizeDistributionParityValue(observation.outcome, options);
+            const normalizedReference = normalizeDistributionParityValue(reference?.outcome, options);
+            const comparison = runtime.kind === "source_checkout"
+                ? observation.state === "supported"
+                    ? "match"
+                    : observation.state
+                : compareObservation(observation, reference, normalized, normalizedReference);
+            if (runtime.kind !== "project_resolved" &&
+                observation.state === "unsupported") {
+                issues.push({
+                    code: "current_capability_unsupported",
+                    runtimeId: runtime.id,
+                    surface: runtime.surface,
+                    capability,
+                    detail: `Current ${runtime.kind} runtime does not support ${capability}.`,
+                });
+            }
+            if (observation.state === "failed") {
+                issues.push({
+                    code: "capability_execution_failed",
+                    runtimeId: runtime.id,
+                    surface: runtime.surface,
+                    capability,
+                    detail: observation.detail ??
+                        `Runtime ${runtime.id} failed while executing ${capability}.`,
+                });
+            }
+            if (runtime.kind === "packed_artifact" && comparison === "diverged") {
+                issues.push({
+                    code: "source_packed_mismatch",
+                    runtimeId: runtime.id,
+                    surface: runtime.surface,
+                    capability,
+                    detail: `Packed ${runtime.surface} outcome diverges from source for ${capability}.`,
+                });
+            }
+            if (runtime.kind === "project_resolved" &&
+                (comparison === "diverged" || comparison === "unsupported") &&
+                !action) {
+                issues.push({
+                    code: "project_divergence_without_action",
+                    runtimeId: runtime.id,
+                    surface: runtime.surface,
+                    capability,
+                    detail: `Project runtime ${runtime.id} needs an upgrade or compatibility action for ${capability}.`,
+                });
+            }
+            rows.push({
+                runtimeId: runtime.id,
+                kind: runtime.kind,
+                surface: runtime.surface,
+                ...(runtime.project === undefined ? {} : { project: runtime.project }),
+                capability,
+                state: observation.state,
+                comparison,
+                ...(runtime.kind === "source_checkout" || source === undefined
+                    ? {}
+                    : { referenceRuntimeId: source.id }),
+                ...(observation.state === "supported"
+                    ? { normalizedOutcome: normalized }
+                    : {}),
+                diagnosticIds: sortedUnique(observation.diagnosticIds),
+                ...(action === undefined ? {} : { action }),
+                ...(observation.detail === undefined
+                    ? {}
+                    : { detail: observation.detail }),
+            });
+        }
+    }
+    return {
+        version: DISTRIBUTION_PARITY_VERSION,
+        status: issues.length === 0 ? "passed" : "failed",
+        capabilities: REQUIREMENT_COMPILER_CAPABILITIES,
+        runtimes: [...runtimes].sort((left, right) => left.id.localeCompare(right.id)),
+        rows,
+        issues,
+        summary: {
+            runtimeCount: runtimes.length,
+            observationCount: observations.length,
+            matchCount: rows.filter((row) => row.comparison === "match").length,
+            divergenceCount: rows.filter((row) => row.comparison === "diverged")
+                .length,
+            unsupportedCount: rows.filter((row) => row.state === "unsupported")
+                .length,
+            failedCount: rows.filter((row) => row.state === "failed").length,
+            actionCount: rows.filter((row) => row.action !== undefined).length,
+        },
+    };
+}
+// implements REQ-kibi-distribution-parity-matrix
+export async function runDistributionParityMatrix(adapters, options = {}) {
+    const observations = [];
+    for (const adapter of adapters) {
+        for (const capability of REQUIREMENT_COMPILER_CAPABILITIES) {
+            try {
+                const result = await adapter.execute(capability);
+                observations.push({
+                    runtimeId: adapter.runtime.id,
+                    capability,
+                    ...result,
+                });
+            }
+            catch (error) {
+                observations.push({
+                    runtimeId: adapter.runtime.id,
+                    capability,
+                    state: "failed",
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    return buildDistributionParityReport(adapters.map((adapter) => adapter.runtime), observations, options);
+}

package/dist/public/impact/full-kb-quality.d.ts

@@ -4,6 +4,8 @@ type FullKbQualityDiagnosticsOptions = {
     readonly prolog: Pick<PrologProcess, "query">;
     readonly hardViolationEntityIds?: ReadonlySet<string>;
     readonly maxDiagnostics?: number;
+    readonly workspaceRoot?: string;
+    readonly now?: Date;
 };
 export declare function collectFullKbQualityDiagnostics(options: FullKbQualityDiagnosticsOptions): Promise<readonly QualityDiagnostic[]>;
 export {};

package/dist/public/impact/full-kb-quality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"full-kb-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/full-kb-quality.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AASrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAqBpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC9C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AA0KF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAmBvC"}
+{"version":3,"file":"full-kb-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/full-kb-quality.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAcrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAqBpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC9C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;CACrB,CAAC;AAmOF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CA0BvC"}

package/dist/public/impact/full-kb-quality.js

@@ -1,4 +1,7 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
 import { parseEntityFromList, parseListOfLists, parseTriples, } from "../../prolog/codec.js";
+import { analyzeTelemetryAcceptance, createTelemetryAcceptanceDiagnostics, parseTelemetryUsageLog, } from "../telemetry-acceptance.js";
 import { createCoverageDepthQualityDiagnostics } from "./coverage-depth-quality.js";
 import { createRequirementQualityDiagnostics } from "./requirement-quality.js";
 import { createSymbolQualityDiagnostics } from "./symbol-quality.js";
@@ -63,6 +66,9 @@ function toExtractedEntity(entity) {
     const textRef = optionalStringField(entity, "text_ref");
     if (textRef !== undefined)
         extracted.text_ref = textRef;
+    const semanticText = optionalStringField(entity, "semantic_text");
+    if (semanticText !== undefined)
+        extracted.semantic_text = semanticText;
     const logicClaims = optionalStringArrayField(entity, "logic_claims");
     if (logicClaims !== undefined)
         extracted.logic_claims = logicClaims;
@@ -171,10 +177,56 @@ function capDiagnostics(diagnostics, maxDiagnostics) {
         ? diagnostics.slice(0, maxDiagnostics)
         : diagnostics;
 }
+function telemetryReadDiagnostic(message) {
+    return {
+        id: "telemetry_evidence_unreadable",
+        severity: "review",
+        blocking: false,
+        category: "telemetry",
+        source: ".kb/usage.log",
+        message,
+        suggestion: "Repair or regenerate .kb/usage.log through Kibi diagnostic mode, then rerun kibi usage-metrics --require-acceptance and an unfiltered kb_check.",
+    };
+}
+async function collectTelemetryDiagnostics(workspaceRoot, now) {
+    if (workspaceRoot === undefined)
+        return [];
+    const usageLogPath = path.join(workspaceRoot, ".kb", "usage.log");
+    let contents;
+    try {
+        contents = await readFile(usageLogPath, "utf8");
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return [];
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return [
+            telemetryReadDiagnostic(`Telemetry acceptance evidence is unreadable: ${message}`),
+        ];
+    }
+    try {
+        const report = analyzeTelemetryAcceptance(parseTelemetryUsageLog(contents), now);
+        return createTelemetryAcceptanceDiagnostics(report);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return [
+            telemetryReadDiagnostic(`Telemetry acceptance evidence is malformed: ${message}`),
+        ];
+    }
+}
 export async function collectFullKbQualityDiagnostics(options) {
-    const manifestResults = await loadKbExtractionResults(options.prolog);
+    const [manifestResults, telemetryDiagnostics] = await Promise.all([
+        loadKbExtractionResults(options.prolog),
+        collectTelemetryDiagnostics(options.workspaceRoot, options.now ?? new Date()),
+    ]);
     const coverageDepthDiagnostics = createCoverageDepthQualityDiagnostics(manifestResults);
     const diagnostics = [
+        ...telemetryDiagnostics,
         ...createRequirementQualityDiagnostics({
             manifestResults,
             ...(options.hardViolationEntityIds !== undefined

package/dist/public/impact-diagnostics.d.ts

@@ -3,5 +3,7 @@ export { collectFullKbQualityDiagnostics } from "./impact/full-kb-quality.js";
 export { createSemanticReviewDiagnostics, createSymbolGranularityDiagnostics, hasBlockingImpactDiagnostics, hasBlockingQualityDiagnostics, } from "./impact/diagnostics.js";
 export { createRequirementQualityDiagnostics } from "./impact/requirement-quality.js";
 export { createSymbolQualityDiagnostics } from "./impact/symbol-quality.js";
+export { DEFAULT_TELEMETRY_ACCEPTANCE_POLICY, TELEMETRY_ACCEPTANCE_VERSION, analyzeTelemetryAcceptance, createTelemetryAcceptanceDiagnostics, parseTelemetryUsageLog, } from "./telemetry-acceptance.js";
 export type { ChangedFileImpactOptions, ChangedFileImpactResult, ImpactExtractedSymbol, ImpactLinkedEntity, QualityDiagnostic, QualityDiagnosticSeverity, RequirementQualityDiagnosticsOptions, SemanticReviewDiagnosticsOptions, SymbolGranularityDiagnosticsOptions, SymbolQualityDiagnosticsOptions, } from "./impact/types.js";
+export type { TelemetryAcceptanceMetric, TelemetryAcceptancePolicy, TelemetryAcceptanceReport, TelemetryAcceptanceStatus, TelemetryMetricId, TelemetryMetricStatus, TelemetryUsageEvent, } from "./telemetry-acceptance.js";
 //# sourceMappingURL=impact-diagnostics.d.ts.map

package/dist/public/impact-diagnostics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"impact-diagnostics.d.ts","sourceRoot":"","sources":["../../src/public/impact-diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EACL,+BAA+B,EAC/B,kCAAkC,EAClC,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,mCAAmC,EAAE,MAAM,iCAAiC,CAAC;AACtF,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,yBAAyB,EACzB,oCAAoC,EACpC,gCAAgC,EAChC,mCAAmC,EACnC,+BAA+B,GAChC,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"impact-diagnostics.d.ts","sourceRoot":"","sources":["../../src/public/impact-diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EACL,+BAA+B,EAC/B,kCAAkC,EAClC,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,mCAAmC,EAAE,MAAM,iCAAiC,CAAC;AACtF,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EACL,mCAAmC,EACnC,4BAA4B,EAC5B,0BAA0B,EAC1B,oCAAoC,EACpC,sBAAsB,GACvB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,yBAAyB,EACzB,oCAAoC,EACpC,gCAAgC,EAChC,mCAAmC,EACnC,+BAA+B,GAChC,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,2BAA2B,CAAC"}

package/dist/public/impact-diagnostics.js

@@ -3,3 +3,4 @@ export { collectFullKbQualityDiagnostics } from "./impact/full-kb-quality.js";
 export { createSemanticReviewDiagnostics, createSymbolGranularityDiagnostics, hasBlockingImpactDiagnostics, hasBlockingQualityDiagnostics, } from "./impact/diagnostics.js";
 export { createRequirementQualityDiagnostics } from "./impact/requirement-quality.js";
 export { createSymbolQualityDiagnostics } from "./impact/symbol-quality.js";
+export { DEFAULT_TELEMETRY_ACCEPTANCE_POLICY, TELEMETRY_ACCEPTANCE_VERSION, analyzeTelemetryAcceptance, createTelemetryAcceptanceDiagnostics, parseTelemetryUsageLog, } from "./telemetry-acceptance.js";