@mcoda/mswarm 0.1.90 → 0.1.91

package/dist/vendor/codali/storage/CodaliDatasetPrivacyEngine.d.ts

@@ -0,0 +1,138 @@
+import { type CodaliStorageObjectPrivacyFlags, type CodaliStorageObjectRef, type CodaliStorageObjectRetentionClass, type CodaliStoragePrivacyClassification, type CodaliStoragePrivacyMetadata } from "./CodaliStorageContracts.js";
+export type CodaliDatasetPrivacyPurpose = "training" | "export" | "eval" | "replay" | "durable_persistence";
+export type CodaliDatasetSecretFindingKind = "sensitive_key" | "bearer_token" | "openai_api_key" | "cloud_access_key" | "github_token" | "jwt" | "private_key" | "env_secret_assignment";
+export type CodaliDatasetEligibilityBlockerCode = "secrets_detected" | "privacy_training_not_allowed" | "privacy_export_not_allowed" | "object_training_not_allowed" | "object_export_not_allowed" | "object_eval_not_allowed" | "object_replay_not_allowed" | "retention_do_not_store" | "redaction_required" | "policy_override_requires_admin_audit" | "policy_override_not_requested" | "policy_override_hard_blocked";
+export interface CodaliDatasetSecretFinding {
+    kind: CodaliDatasetSecretFindingKind;
+    path: string;
+    redacted: boolean;
+}
+export interface CodaliDatasetSecretDetectionResult<TPayload = unknown> {
+    containsSecrets: boolean;
+    findings: CodaliDatasetSecretFinding[];
+    redactedPayload: TPayload;
+}
+export interface CodaliDatasetTenantScope {
+    tenantId: string;
+    tenantSalt: string;
+}
+export interface CodaliDatasetIdentifierInput {
+    tenantId: string;
+    requesterId?: string;
+    conversationId?: string;
+    repoId?: string;
+    sourceId?: string;
+    reviewerId?: string;
+    deletionGroupId?: string;
+}
+export interface CodaliDatasetHashedIdentifiers {
+    tenantHash: string;
+    requesterHash?: string;
+    conversationHash?: string;
+    repoHash?: string;
+    sourceHash?: string;
+    reviewerHash?: string;
+    deletionGroupHash?: string;
+}
+export interface CodaliDatasetPrivacyAllowances {
+    uploadAllowed?: boolean;
+    trainingAllowed?: boolean;
+    evalAllowed?: boolean;
+    replayAllowed?: boolean;
+    exportAllowed?: boolean;
+}
+export interface CodaliDatasetPrivacyMetadataInput {
+    tenant: CodaliDatasetTenantScope;
+    identifiers: Omit<CodaliDatasetIdentifierInput, "tenantId">;
+    inputPayload?: unknown;
+    outputPayload?: unknown;
+    evidencePayloads?: unknown[];
+    classification?: CodaliStoragePrivacyClassification;
+    containsPersonalData?: boolean;
+    containsTenantPrivateData?: boolean;
+    containsSourceCode?: boolean;
+    containsCustomerData?: boolean;
+    personalDataRedacted?: boolean;
+    allowances?: CodaliDatasetPrivacyAllowances;
+    retentionClass?: CodaliStorageObjectRetentionClass;
+    policyTags?: string[];
+    retentionUntil?: string;
+    metadata?: Record<string, unknown>;
+    now?: string;
+}
+export interface CodaliDatasetPrivacyEnvelope {
+    privacy: CodaliStoragePrivacyMetadata;
+    privacyFlags: CodaliStorageObjectPrivacyFlags;
+    hashedIdentifiers: CodaliDatasetHashedIdentifiers;
+    redactedPayloads: {
+        inputPayload?: unknown;
+        outputPayload?: unknown;
+        evidencePayloads?: unknown[];
+    };
+    secretFindings: CodaliDatasetSecretFinding[];
+    eligibility: {
+        trainingAllowed: boolean;
+        evalAllowed: boolean;
+        replayAllowed: boolean;
+        exportAllowed: boolean;
+        durablePersistenceAllowed: boolean;
+        blockers: CodaliDatasetEligibilityBlocker[];
+    };
+}
+export interface CodaliDatasetEligibilityBlocker {
+    code: CodaliDatasetEligibilityBlockerCode;
+    message: string;
+    path?: string;
+}
+export interface CodaliDatasetEligibilityDecision {
+    purpose: CodaliDatasetPrivacyPurpose;
+    allowed: boolean;
+    blockers: CodaliDatasetEligibilityBlocker[];
+    auditEvents?: CodaliDatasetPolicyAuditEvent[];
+}
+export interface CodaliDatasetPolicyOverride {
+    purpose: CodaliDatasetPrivacyPurpose;
+    allow: boolean;
+    adminActorId?: string;
+    auditEventId?: string;
+    reason?: string;
+    approvedAt?: string;
+}
+export interface CodaliDatasetPolicyAuditEvent {
+    auditEventId: string;
+    adminActorId: string;
+    purpose: CodaliDatasetPrivacyPurpose;
+    reason: string;
+    approvedAt: string;
+    originalBlockers: CodaliDatasetEligibilityBlockerCode[];
+}
+export interface CodaliDatasetPayloadReadInput<TPayload> {
+    purpose: Exclude<CodaliDatasetPrivacyPurpose, "durable_persistence">;
+    objectRef: CodaliStorageObjectRef;
+    privacy: CodaliStoragePrivacyMetadata;
+    policyOverride?: CodaliDatasetPolicyOverride;
+    readPayload: (objectRef: CodaliStorageObjectRef) => Promise<TPayload> | TPayload;
+}
+export type CodaliDatasetPayloadReadResult<TPayload> = {
+    ok: true;
+    decision: CodaliDatasetEligibilityDecision;
+    payload: TPayload;
+} | {
+    ok: false;
+    decision: CodaliDatasetEligibilityDecision;
+};
+export declare class CodaliDatasetPrivacyError extends Error {
+    readonly decision: CodaliDatasetEligibilityDecision;
+    constructor(decision: CodaliDatasetEligibilityDecision);
+}
+export declare const detectAndRedactCodaliDatasetSecrets: <TPayload = unknown>(payload: TPayload) => CodaliDatasetSecretDetectionResult<TPayload>;
+export declare const hashCodaliDatasetIdentifier: (tenant: CodaliDatasetTenantScope, scope: keyof CodaliDatasetHashedIdentifiers, value: string) => string;
+export declare const hashCodaliDatasetIdentifiers: (tenant: CodaliDatasetTenantScope, identifiers: Omit<CodaliDatasetIdentifierInput, "tenantId">) => CodaliDatasetHashedIdentifiers;
+export declare const evaluateCodaliDatasetDurablePersistence: (retentionClass: CodaliStorageObjectRetentionClass) => CodaliDatasetEligibilityDecision;
+export declare const evaluateCodaliDatasetObjectPayloadRead: (purpose: Exclude<CodaliDatasetPrivacyPurpose, "durable_persistence">, objectRef: CodaliStorageObjectRef, privacy: CodaliStoragePrivacyMetadata) => CodaliDatasetEligibilityDecision;
+export declare const applyCodaliDatasetPolicyOverride: (decision: CodaliDatasetEligibilityDecision, override?: CodaliDatasetPolicyOverride) => CodaliDatasetEligibilityDecision;
+export declare const assertCodaliDatasetObjectPayloadReadAllowed: (purpose: Exclude<CodaliDatasetPrivacyPurpose, "durable_persistence">, objectRef: CodaliStorageObjectRef, privacy: CodaliStoragePrivacyMetadata) => void;
+export declare const assertCodaliDatasetDurablePersistenceAllowed: (retentionClass: CodaliStorageObjectRetentionClass) => void;
+export declare const readCodaliDatasetObjectPayload: <TPayload>(input: CodaliDatasetPayloadReadInput<TPayload>) => Promise<CodaliDatasetPayloadReadResult<TPayload>>;
+export declare const generateCodaliDatasetPrivacyMetadata: (input: CodaliDatasetPrivacyMetadataInput) => CodaliDatasetPrivacyEnvelope;
+//# sourceMappingURL=CodaliDatasetPrivacyEngine.d.ts.map

package/dist/vendor/codali/storage/CodaliDatasetPrivacyEngine.d.ts.map

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

package/dist/vendor/codali/storage/CodaliDatasetPrivacyEngine.js

@@ -0,0 +1,417 @@
+import { createHmac } from "node:crypto";
+import { CODALI_STORAGE_CONTRACT_SCHEMA_VERSION, isCodaliStoragePrivacyExportAllowed, isCodaliStoragePrivacyTrainingAllowed, } from "./CodaliStorageContracts.js";
+export class CodaliDatasetPrivacyError extends Error {
+    constructor(decision) {
+        super(`Codali dataset privacy check failed for ${decision.purpose}: ${decision.blockers
+            .map((blocker) => blocker.code)
+            .join(", ")}`);
+        this.name = "CodaliDatasetPrivacyError";
+        this.decision = decision;
+    }
+}
+const REDACTION_TOKEN = "[redacted]";
+const SENSITIVE_KEY_PATTERNS = [
+    /(^|[_-])(api[_-]?key|access[_-]?key|secret|token|password|passwd|credential|authorization|auth[_-]?token|private[_-]?key|signing[_-]?key)([_-]|$)/i,
+];
+const SECRET_VALUE_PATTERNS = [
+    {
+        kind: "private_key",
+        pattern: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
+    },
+    { kind: "bearer_token", pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/g },
+    { kind: "openai_api_key", pattern: /\bsk-[A-Za-z0-9_-]{16,}\b/g },
+    { kind: "cloud_access_key", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+    { kind: "github_token", pattern: /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g },
+    {
+        kind: "jwt",
+        pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g,
+    },
+    {
+        kind: "env_secret_assignment",
+        pattern: /\b(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|PRIVATE[_-]?KEY)=["']?[^"'\s]{8,}["']?/gi,
+    },
+];
+const PERSONAL_KEY_PATTERNS = [
+    /(^|[_-])(email|phone|ssn|person|user[_-]?id|requester)([_-]|$)/i,
+];
+const PERSONAL_VALUE_PATTERNS = [
+    /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi,
+];
+const HARD_OVERRIDE_BLOCKERS = new Set([
+    "secrets_detected",
+    "retention_do_not_store",
+    "redaction_required",
+]);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const hasText = (value) => typeof value === "string" && value.trim().length > 0;
+const normalizeIdentifier = (value) => {
+    if (!hasText(value))
+        return undefined;
+    return value.trim();
+};
+const pathForKey = (basePath, key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
+    ? `${basePath}.${key}`
+    : `${basePath}[${JSON.stringify(key)}]`;
+const isSensitiveKey = (key) => SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+const isPersonalKey = (key) => PERSONAL_KEY_PATTERNS.some((pattern) => pattern.test(key));
+const stringContainsPersonalData = (value) => PERSONAL_VALUE_PATTERNS.some((pattern) => {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+});
+const redactString = (value, path, findings) => {
+    let redacted = value;
+    for (const { kind, pattern } of SECRET_VALUE_PATTERNS) {
+        pattern.lastIndex = 0;
+        if (!pattern.test(redacted))
+            continue;
+        pattern.lastIndex = 0;
+        redacted = redacted.replace(pattern, () => {
+            findings.push({ kind, path, redacted: true });
+            return REDACTION_TOKEN;
+        });
+    }
+    return redacted;
+};
+const redactPayloadValue = (value, path, findings) => {
+    if (typeof value === "string")
+        return redactString(value, path, findings);
+    if (Array.isArray(value)) {
+        return value.map((item, index) => redactPayloadValue(item, `${path}[${index}]`, findings));
+    }
+    if (!isRecord(value))
+        return value;
+    const redacted = {};
+    for (const [key, child] of Object.entries(value)) {
+        const childPath = pathForKey(path, key);
+        if (isSensitiveKey(key) && child !== null && child !== undefined && child !== "") {
+            findings.push({ kind: "sensitive_key", path: childPath, redacted: true });
+            redacted[key] = REDACTION_TOKEN;
+            continue;
+        }
+        redacted[key] = redactPayloadValue(child, childPath, findings);
+    }
+    return redacted;
+};
+const payloadContainsPersonalData = (value) => {
+    if (typeof value === "string")
+        return stringContainsPersonalData(value);
+    if (Array.isArray(value))
+        return value.some(payloadContainsPersonalData);
+    if (!isRecord(value))
+        return false;
+    return Object.entries(value).some(([key, child]) => isPersonalKey(key) || payloadContainsPersonalData(child));
+};
+const metadataContainsSecrets = (privacy) => privacy.metadata?.containsSecrets === true ||
+    privacy.metadata?.contains_secrets === true;
+const addBlocker = (blockers, code, message, path) => {
+    blockers.push(path ? { code, message, path } : { code, message });
+};
+export const detectAndRedactCodaliDatasetSecrets = (payload) => {
+    const findings = [];
+    const redactedPayload = redactPayloadValue(payload, "$", findings);
+    return {
+        containsSecrets: findings.length > 0,
+        findings,
+        redactedPayload,
+    };
+};
+export const hashCodaliDatasetIdentifier = (tenant, scope, value) => {
+    const normalizedTenantId = tenant.tenantId.trim();
+    const normalizedTenantSalt = tenant.tenantSalt.trim();
+    const normalizedValue = value.trim();
+    if (!normalizedTenantId) {
+        throw new Error("tenantId is required for Codali dataset identifier hashing");
+    }
+    if (!normalizedTenantSalt) {
+        throw new Error("tenantSalt is required for Codali dataset identifier hashing");
+    }
+    if (!normalizedValue) {
+        throw new Error("value is required for Codali dataset identifier hashing");
+    }
+    const digest = createHmac("sha256", `${normalizedTenantSalt}:${normalizedTenantId}`)
+        .update(`${scope}:${normalizedValue}`)
+        .digest("hex");
+    return `sha256:${digest}`;
+};
+export const hashCodaliDatasetIdentifiers = (tenant, identifiers) => {
+    const tenantId = normalizeIdentifier(tenant.tenantId);
+    if (!tenantId) {
+        throw new Error("tenantId is required for Codali dataset identifier hashing");
+    }
+    const hashOptional = (scope, value) => {
+        const normalized = normalizeIdentifier(value);
+        return normalized
+            ? hashCodaliDatasetIdentifier(tenant, scope, normalized)
+            : undefined;
+    };
+    return {
+        tenantHash: hashCodaliDatasetIdentifier(tenant, "tenantHash", tenantId),
+        requesterHash: hashOptional("requesterHash", identifiers.requesterId),
+        conversationHash: hashOptional("conversationHash", identifiers.conversationId),
+        repoHash: hashOptional("repoHash", identifiers.repoId),
+        sourceHash: hashOptional("sourceHash", identifiers.sourceId),
+        reviewerHash: hashOptional("reviewerHash", identifiers.reviewerId),
+        deletionGroupHash: hashOptional("deletionGroupHash", identifiers.deletionGroupId),
+    };
+};
+export const evaluateCodaliDatasetDurablePersistence = (retentionClass) => {
+    const blockers = [];
+    if (retentionClass === "do_not_store") {
+        addBlocker(blockers, "retention_do_not_store", "Durable persistence is rejected for retention_class=do_not_store.", "$.retentionClass");
+    }
+    return {
+        purpose: "durable_persistence",
+        allowed: blockers.length === 0,
+        blockers,
+    };
+};
+export const evaluateCodaliDatasetObjectPayloadRead = (purpose, objectRef, privacy) => {
+    const blockers = [];
+    if (objectRef.retentionClass === "do_not_store") {
+        addBlocker(blockers, "retention_do_not_store", "Object payload reads are rejected for retention_class=do_not_store.", "$.retentionClass");
+    }
+    const containsSecrets = objectRef.privacyFlags.containsSecrets || metadataContainsSecrets(privacy);
+    if ((purpose === "training" || purpose === "export") && containsSecrets) {
+        addBlocker(blockers, "secrets_detected", "Records containing secrets cannot be training or export eligible.", "$.privacyFlags.containsSecrets");
+    }
+    if ((purpose === "training" || purpose === "export") &&
+        privacy.containsPersonalData &&
+        privacy.redactionStatus !== "redacted") {
+        addBlocker(blockers, "redaction_required", "Personal data must be redacted before training or export reads.", "$.privacy.redactionStatus");
+    }
+    if (purpose === "training") {
+        if (!isCodaliStoragePrivacyTrainingAllowed(privacy)) {
+            addBlocker(blockers, "privacy_training_not_allowed", "Privacy metadata does not allow training.", "$.privacy.trainingAllowed");
+        }
+        if (!objectRef.privacyFlags.trainingAllowed) {
+            addBlocker(blockers, "object_training_not_allowed", "Object privacy flags do not allow training.", "$.privacyFlags.trainingAllowed");
+        }
+    }
+    if (purpose === "export") {
+        if (!isCodaliStoragePrivacyExportAllowed(privacy)) {
+            addBlocker(blockers, "privacy_export_not_allowed", "Privacy metadata does not allow export.", "$.privacy.exportAllowed");
+        }
+        if (!objectRef.privacyFlags.exportAllowed) {
+            addBlocker(blockers, "object_export_not_allowed", "Object privacy flags do not allow export.", "$.privacyFlags.exportAllowed");
+        }
+    }
+    if (purpose === "eval" && !objectRef.privacyFlags.evalAllowed) {
+        addBlocker(blockers, "object_eval_not_allowed", "Object privacy flags do not allow eval reads.", "$.privacyFlags.evalAllowed");
+    }
+    if (purpose === "replay" && !objectRef.privacyFlags.replayAllowed) {
+        addBlocker(blockers, "object_replay_not_allowed", "Object privacy flags do not allow replay reads.", "$.privacyFlags.replayAllowed");
+    }
+    return {
+        purpose,
+        allowed: blockers.length === 0,
+        blockers,
+    };
+};
+const hasAdminAudit = (override) => override.allow === true &&
+    hasText(override.adminActorId) &&
+    hasText(override.auditEventId) &&
+    hasText(override.reason);
+export const applyCodaliDatasetPolicyOverride = (decision, override) => {
+    if (!override)
+        return decision;
+    if (!override.allow || override.purpose !== decision.purpose) {
+        return decision.allowed
+            ? decision
+            : {
+                ...decision,
+                blockers: [
+                    ...decision.blockers,
+                    {
+                        code: "policy_override_not_requested",
+                        message: "No matching policy override was requested.",
+                    },
+                ],
+            };
+    }
+    if (!hasAdminAudit(override)) {
+        return {
+            ...decision,
+            allowed: false,
+            blockers: [
+                ...decision.blockers,
+                {
+                    code: "policy_override_requires_admin_audit",
+                    message: "Policy overrides require an admin actor, audit event id, reason, and explicit allow=true.",
+                },
+            ],
+        };
+    }
+    const hardBlockers = decision.blockers.filter((blocker) => HARD_OVERRIDE_BLOCKERS.has(blocker.code));
+    if (hardBlockers.length > 0) {
+        return {
+            ...decision,
+            allowed: false,
+            blockers: [
+                ...decision.blockers,
+                {
+                    code: "policy_override_hard_blocked",
+                    message: "Policy override cannot bypass secrets, required redaction, or do_not_store retention.",
+                },
+            ],
+        };
+    }
+    const auditEvent = {
+        auditEventId: override.auditEventId.trim(),
+        adminActorId: override.adminActorId.trim(),
+        purpose: decision.purpose,
+        reason: override.reason.trim(),
+        approvedAt: override.approvedAt ?? new Date().toISOString(),
+        originalBlockers: decision.blockers.map((blocker) => blocker.code),
+    };
+    return {
+        purpose: decision.purpose,
+        allowed: true,
+        blockers: [],
+        auditEvents: [...(decision.auditEvents ?? []), auditEvent],
+    };
+};
+export const assertCodaliDatasetObjectPayloadReadAllowed = (purpose, objectRef, privacy) => {
+    const decision = evaluateCodaliDatasetObjectPayloadRead(purpose, objectRef, privacy);
+    if (!decision.allowed)
+        throw new CodaliDatasetPrivacyError(decision);
+};
+export const assertCodaliDatasetDurablePersistenceAllowed = (retentionClass) => {
+    const decision = evaluateCodaliDatasetDurablePersistence(retentionClass);
+    if (!decision.allowed)
+        throw new CodaliDatasetPrivacyError(decision);
+};
+export const readCodaliDatasetObjectPayload = async (input) => {
+    const baseDecision = evaluateCodaliDatasetObjectPayloadRead(input.purpose, input.objectRef, input.privacy);
+    const decision = applyCodaliDatasetPolicyOverride(baseDecision, input.policyOverride);
+    if (!decision.allowed)
+        return { ok: false, decision };
+    return {
+        ok: true,
+        decision,
+        payload: await input.readPayload(input.objectRef),
+    };
+};
+export const generateCodaliDatasetPrivacyMetadata = (input) => {
+    const inputSecrets = detectAndRedactCodaliDatasetSecrets(input.inputPayload);
+    const outputSecrets = detectAndRedactCodaliDatasetSecrets(input.outputPayload);
+    const evidenceSecrets = (input.evidencePayloads ?? []).map((payload) => detectAndRedactCodaliDatasetSecrets(payload));
+    const secretFindings = [
+        ...inputSecrets.findings.map((finding) => ({
+            ...finding,
+            path: `$.inputPayload${finding.path.slice(1)}`,
+        })),
+        ...outputSecrets.findings.map((finding) => ({
+            ...finding,
+            path: `$.outputPayload${finding.path.slice(1)}`,
+        })),
+        ...evidenceSecrets.flatMap((result, index) => result.findings.map((finding) => ({
+            ...finding,
+            path: `$.evidencePayloads[${index}]${finding.path.slice(1)}`,
+        }))),
+    ];
+    const containsSecrets = secretFindings.length > 0;
+    const containsPersonalData = input.containsPersonalData === true ||
+        payloadContainsPersonalData(input.inputPayload) ||
+        payloadContainsPersonalData(input.outputPayload) ||
+        (input.evidencePayloads ?? []).some(payloadContainsPersonalData);
+    const retentionClass = input.retentionClass ?? "dataset";
+    const durablePersistence = evaluateCodaliDatasetDurablePersistence(retentionClass);
+    const durablePersistenceAllowed = durablePersistence.allowed;
+    const personalDataRedacted = input.personalDataRedacted === true;
+    const redactionStatus = containsSecrets
+        ? containsPersonalData && !personalDataRedacted
+            ? "pending"
+            : "redacted"
+        : containsPersonalData
+            ? personalDataRedacted
+                ? "redacted"
+                : "pending"
+            : "not_required";
+    const redactionReady = !containsPersonalData || redactionStatus === "redacted";
+    const trainingAllowed = input.allowances?.trainingAllowed === true &&
+        durablePersistenceAllowed &&
+        !containsSecrets &&
+        redactionReady;
+    const exportAllowed = input.allowances?.exportAllowed === true &&
+        durablePersistenceAllowed &&
+        !containsSecrets &&
+        redactionReady;
+    const uploadAllowed = input.allowances?.uploadAllowed === true &&
+        durablePersistenceAllowed &&
+        redactionReady &&
+        !containsSecrets;
+    const evalAllowed = input.allowances?.evalAllowed === true && durablePersistenceAllowed;
+    const replayAllowed = input.allowances?.replayAllowed === true && durablePersistenceAllowed;
+    const hashedIdentifiers = hashCodaliDatasetIdentifiers(input.tenant, {
+        ...input.identifiers,
+    });
+    const metadata = {
+        ...(input.metadata ?? {}),
+        containsSecrets,
+        secretFindingCount: secretFindings.length,
+        secretFindingKinds: Array.from(new Set(secretFindings.map((finding) => finding.kind))),
+        hashedIdentifiers,
+        retentionClass,
+        generatedAt: input.now ?? new Date().toISOString(),
+    };
+    const privacy = {
+        schemaVersion: CODALI_STORAGE_CONTRACT_SCHEMA_VERSION,
+        classification: input.classification ?? "internal",
+        containsPersonalData,
+        redactionStatus,
+        uploadAllowed,
+        exportAllowed,
+        trainingAllowed,
+        policyTags: input.policyTags,
+        retentionUntil: input.retentionUntil,
+        redactionSummary: containsSecrets
+            ? `${secretFindings.length} secret finding(s) redacted.`
+            : undefined,
+        metadata,
+    };
+    const privacyFlags = {
+        containsPersonalData,
+        containsSecrets,
+        containsTenantPrivateData: input.containsTenantPrivateData === true,
+        containsSourceCode: input.containsSourceCode === true,
+        containsCustomerData: input.containsCustomerData === true,
+        trainingAllowed,
+        evalAllowed,
+        replayAllowed,
+        exportAllowed,
+    };
+    const blockers = [
+        ...durablePersistence.blockers,
+    ];
+    if (containsSecrets) {
+        addBlocker(blockers, "secrets_detected", "Records containing secrets cannot be training or export eligible.", "$.metadata.containsSecrets");
+    }
+    if (containsPersonalData && redactionStatus !== "redacted") {
+        addBlocker(blockers, "redaction_required", "Personal data must be redacted before training or export eligibility.", "$.redactionStatus");
+    }
+    if (input.allowances?.trainingAllowed === true && !trainingAllowed) {
+        addBlocker(blockers, "privacy_training_not_allowed", "Requested training eligibility was denied by privacy policy.", "$.trainingAllowed");
+    }
+    if (input.allowances?.exportAllowed === true && !exportAllowed) {
+        addBlocker(blockers, "privacy_export_not_allowed", "Requested export eligibility was denied by privacy policy.", "$.exportAllowed");
+    }
+    return {
+        privacy,
+        privacyFlags,
+        hashedIdentifiers,
+        redactedPayloads: {
+            inputPayload: inputSecrets.redactedPayload,
+            outputPayload: outputSecrets.redactedPayload,
+            evidencePayloads: evidenceSecrets.map((result) => result.redactedPayload),
+        },
+        secretFindings,
+        eligibility: {
+            trainingAllowed,
+            evalAllowed,
+            replayAllowed,
+            exportAllowed,
+            durablePersistenceAllowed,
+            blockers,
+        },
+    };
+};

package/dist/vendor/codali/storage/CodaliFeedbackReviewIngestion.d.ts

@@ -0,0 +1,50 @@
+import { type CodaliStorageCandidateRecordRef, type CodaliStorageDatasetRecord, type CodaliStorageFeedbackRecord, type CodaliStorageFeedbackSource, type CodaliStoragePrivacyMetadata, type CodaliStorageProductScope, type CodaliStorageRecordType, type CodaliStorageRequesterScope, type CodaliStorageReviewDecision, type CodaliStorageReviewerType, type CodaliStorageReviewPromotionTarget, type CodaliStorageReviewRecord, type CodaliStorageValidationIssue } from "./CodaliStorageContracts.js";
+export declare class CodaliFeedbackReviewIngestionError extends Error {
+    readonly issues: CodaliStorageValidationIssue[];
+    constructor(message: string, issues: CodaliStorageValidationIssue[]);
+}
+export type CodaliFeedbackReviewRequesterScopeInput = Omit<CodaliStorageRequesterScope, "visibility" | "tenantWide"> & Partial<Pick<CodaliStorageRequesterScope, "visibility" | "tenantWide">>;
+export interface CodaliFeedbackReviewScopeInput {
+    runId: string;
+    deletionGroupId?: string;
+    productScope: CodaliStorageProductScope;
+    requesterScope: CodaliFeedbackReviewRequesterScopeInput;
+    candidateRecords: CodaliStorageCandidateRecordRef[];
+    privacy?: Partial<CodaliStoragePrivacyMetadata>;
+    metadata?: Record<string, unknown>;
+}
+export interface BuildCodaliStorageFeedbackRecordInput extends CodaliFeedbackReviewScopeInput {
+    feedbackId: string;
+    createdAt?: string;
+    source: CodaliStorageFeedbackSource;
+    targetType: CodaliStorageRecordType;
+    targetId: string;
+    rating?: number;
+    comment?: string;
+    labels?: string[];
+}
+export interface BuildCodaliStorageReviewRecordInput extends CodaliFeedbackReviewScopeInput {
+    reviewId: string;
+    createdAt?: string;
+    reviewerType: CodaliStorageReviewerType;
+    reviewerId?: string;
+    targetType: CodaliStorageRecordType;
+    targetId: string;
+    decision: CodaliStorageReviewDecision;
+    reasons?: string[];
+    labels?: string[];
+    promotionTarget?: CodaliStorageReviewPromotionTarget;
+    promotedRecordIds?: string[];
+}
+export interface ApplyCodaliStorageReviewPromotionInput {
+    review: CodaliStorageReviewRecord;
+    records: CodaliStorageDatasetRecord[];
+    reviewedAt?: string;
+}
+export declare const createCodaliFeedbackReviewLocalOnlyPrivacy: (overrides?: Partial<CodaliStoragePrivacyMetadata>) => CodaliStoragePrivacyMetadata;
+export declare const defaultCodaliStorageReviewPromotionTarget: (decision: CodaliStorageReviewDecision) => CodaliStorageReviewPromotionTarget;
+export declare const normalizeCodaliFeedbackReviewRequesterScope: (requesterScope: CodaliFeedbackReviewRequesterScopeInput) => CodaliStorageRequesterScope;
+export declare const buildCodaliStorageFeedbackRecord: (input: BuildCodaliStorageFeedbackRecordInput) => CodaliStorageFeedbackRecord;
+export declare const buildCodaliStorageReviewRecord: (input: BuildCodaliStorageReviewRecordInput) => CodaliStorageReviewRecord;
+export declare const applyCodaliStorageReviewPromotion: (input: ApplyCodaliStorageReviewPromotionInput) => CodaliStorageDatasetRecord[];
+//# sourceMappingURL=CodaliFeedbackReviewIngestion.d.ts.map

package/dist/vendor/codali/storage/CodaliFeedbackReviewIngestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodaliFeedbackReviewIngestion.d.ts","sourceRoot":"","sources":["../../src/storage/CodaliFeedbackReviewIngestion.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,+BAA+B,EACpC,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,EACjC,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,KAAK,kCAAkC,EACvC,KAAK,yBAAyB,EAC9B,KAAK,4BAA4B,EAClC,MAAM,6BAA6B,CAAC;AAErC,qBAAa,kCAAmC,SAAQ,KAAK;IAGzD,QAAQ,CAAC,MAAM,EAAE,4BAA4B,EAAE;gBAD/C,OAAO,EAAE,MAAM,EACN,MAAM,EAAE,4BAA4B,EAAE;CAKlD;AAED,MAAM,MAAM,uCAAuC,GACjD,IAAI,CAAC,2BAA2B,EAAE,YAAY,GAAG,YAAY,CAAC,GAC9D,OAAO,CAAC,IAAI,CAAC,2BAA2B,EAAE,YAAY,GAAG,YAAY,CAAC,CAAC,CAAC;AAE1E,MAAM,WAAW,8BAA8B;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,yBAAyB,CAAC;IACxC,cAAc,EAAE,uCAAuC,CAAC;IACxD,gBAAgB,EAAE,+BAA+B,EAAE,CAAC;IACpD,OAAO,CAAC,EAAE,OAAO,CAAC,4BAA4B,CAAC,CAAC;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,qCACf,SAAQ,8BAA8B;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,2BAA2B,CAAC;IACpC,UAAU,EAAE,uBAAuB,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,mCACf,SAAQ,8BAA8B;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,yBAAyB,CAAC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,uBAAuB,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,2BAA2B,CAAC;IACtC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,CAAC,EAAE,kCAAkC,CAAC;IACrD,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,sCAAsC;IACrD,MAAM,EAAE,yBAAyB,CAAC;IAClC,OAAO,EAAE,0BAA0B,EAAE,CAAC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,0CAA0C,GACrD,YAAW,OAAO,CAAC,4BAA4B,CAAM,KACpD,4BAaD,CAAC;AAEH,eAAO,MAAM,yCAAyC,GACpD,UAAU,2BAA2B,KACpC,kCAIF,CAAC;AAEF,eAAO,MAAM,2CAA2C,GACtD,gBAAgB,uCAAuC,KACtD,2BAID,CAAC;AAEH,eAAO,MAAM,gCAAgC,GAC3C,OAAO,qCAAqC,KAC3C,2BAyBF,CAAC;AAEF,eAAO,MAAM,8BAA8B,GACzC,OAAO,mCAAmC,KACzC,yBA8BF,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAC5C,OAAO,sCAAsC,KAC5C,0BAA0B,EA+C5B,CAAC"}