agentera 3.0.0-dev.7 → 3.0.0-dev.74

package/dist/registries/glossaryCandidateDecisionAuthority.js

@@ -0,0 +1,119 @@
+function mapping(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function strings(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+}
+function exactStrings(actual, expected) {
+    return JSON.stringify(strings(actual)) === JSON.stringify(expected);
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+export const GLOSSARY_ADMISSION_OUTCOMES = [
+    "automatic_admission", "review_required", "abstain",
+];
+export const GLOSSARY_ADMISSION_REASONS_BY_OUTCOME = {
+    automatic_admission: ["explicit_current_authorized"],
+    review_required: [
+        "inferred_requires_review",
+        "scope_ambiguous",
+        "classification_inconsistent",
+        "classification_changed",
+        "entry_conflict",
+        "evidence_retracted_or_conflicted",
+        "quality_gate_not_authorizing",
+    ],
+    abstain: ["scope_project", "evidence_unavailable", "evidence_changed"],
+};
+export const GLOSSARY_ADMISSION_REASONS = [
+    ...GLOSSARY_ADMISSION_REASONS_BY_OUTCOME.automatic_admission,
+    ...GLOSSARY_ADMISSION_REASONS_BY_OUTCOME.review_required,
+    ...GLOSSARY_ADMISSION_REASONS_BY_OUTCOME.abstain,
+];
+export function hasGlossaryAdmissionReasonCodesByOutcome(value) {
+    const reasonCodes = mapping(value);
+    return reasonCodes !== null
+        && exactStrings(Object.keys(reasonCodes), GLOSSARY_ADMISSION_OUTCOMES)
+        && GLOSSARY_ADMISSION_OUTCOMES.every((outcome) => exactStrings(reasonCodes[outcome], GLOSSARY_ADMISSION_REASONS_BY_OUTCOME[outcome]));
+}
+/** Validates the CLI admission layer's authority-owned vocabulary and command contract. */
+export function validateGlossaryCandidateDecisionAuthority(authority) {
+    const errors = [];
+    const candidate = mapping(authority.candidate_contracts);
+    const layers = mapping(candidate?.layers);
+    const decisionLayer = mapping(layers?.cli_decision);
+    if (!exactStrings(decisionLayer?.outcomes, GLOSSARY_ADMISSION_OUTCOMES)) {
+        errors.push("CLI decision outcomes must use the approved vocabulary");
+    }
+    if (!exactStrings(decisionLayer?.reason_codes, GLOSSARY_ADMISSION_REASONS)) {
+        errors.push("CLI decision reasons must use the approved vocabulary");
+    }
+    if (!hasGlossaryAdmissionReasonCodesByOutcome(decisionLayer?.reason_codes_by_outcome)) {
+        errors.push("CLI decision reasons must declare the approved outcome/reason pairs");
+    }
+    const automatic = mapping(decisionLayer?.automatic_admission);
+    const automaticClassification = mapping(automatic?.required_classification);
+    if (automatic?.allowed_provenance !== "provenance_variants.personal_explicit_definition" ||
+        automatic?.inferred_automatic_admission !== "disabled" ||
+        automaticClassification?.scope !== "personal" ||
+        automaticClassification?.consistency !== "consistent" ||
+        automaticClassification?.term !== "exact_capsule_term" ||
+        automaticClassification?.meaning !== "exact_capsule_meaning" ||
+        automatic?.current_evidence !== "required" ||
+        automatic?.quality_gate !== "personal_mining_authority.admission.quality_threshold") {
+        errors.push("CLI automatic admission must be explicit-only and inferred automatic admission disabled");
+    }
+    const command = mapping(decisionLayer?.command);
+    const request = mapping(command?.request);
+    const result = mapping(command?.result);
+    const receiptConstruction = mapping(command?.receipt_construction);
+    const receiptConstructionResult = mapping(receiptConstruction?.result);
+    if (command?.canonical !== "npx -y agentera@next report personal-glossary-decision" ||
+        command?.namespace !== "report" ||
+        command?.input_flag !== "--input" ||
+        command?.stdin_value !== "-" ||
+        command?.format !== "json" ||
+        command?.project_checkout !== "not_required" ||
+        request?.schema_version !== "agentera.personalGlossaryAdmissionRequest.v1" ||
+        !exactStrings(request?.required_fields, ["schema_version", "receipt"]) ||
+        request?.additional_fields !== "forbidden" ||
+        request?.max_utf8_bytes !== 16384 ||
+        result?.schema_version !== "agentera.personalGlossaryAdmissionResult.v1" ||
+        !exactStrings(result?.fields, ["schemaVersion", "command", "status", "decision", "reason", "effects"]) ||
+        !exactStrings(result?.statuses, GLOSSARY_ADMISSION_OUTCOMES) ||
+        result?.max_utf8_bytes !== 4096 ||
+        !exactStrings(result?.effects, []) ||
+        receiptConstruction?.schema_version !== "agentera.personalGlossaryAdmissionRequest.v2" ||
+        !exactStrings(receiptConstruction?.required_fields, [
+            "schema_version",
+            "candidate_id",
+            "candidate_revision",
+            "candidate_capsule_sha256",
+            "candidate_projection_sha256",
+            "generation",
+            "policy_version",
+            "classification",
+        ]) ||
+        receiptConstruction?.additional_fields !== "forbidden" ||
+        receiptConstruction?.max_utf8_bytes !== 16384 ||
+        receiptConstructionResult?.schema_version !== "agentera.personalGlossaryAdmissionResult.v2" ||
+        !exactStrings(receiptConstructionResult?.fields, [
+            "schemaVersion",
+            "command",
+            "status",
+            "receipt",
+            "decision",
+            "reason",
+            "effects",
+        ]) ||
+        !exactStrings(receiptConstructionResult?.statuses, GLOSSARY_ADMISSION_OUTCOMES) ||
+        receiptConstructionResult?.max_utf8_bytes !== 16384 ||
+        !exactStrings(receiptConstructionResult?.effects, []) ||
+        !nonEmpty(command?.rule)) {
+        errors.push("CLI decision command must remain bounded, structured, read-only, and current-projection bound");
+    }
+    return errors;
+}

package/dist/registries/glossaryCandidateDecisionContract.js

@@ -0,0 +1,62 @@
+import { loadYamlMappingFile } from "../core/yaml.js";
+import { projectGlossaryDevelopmentValue } from "../core/developmentInvocation.js";
+import { hasGlossaryAdmissionReasonCodesByOutcome } from "./glossaryCandidateDecisionAuthority.js";
+import { glossaryEntryAuthorityPath } from "./glossaryEntryContract.js";
+function mapping(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function strings(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string")
+        ? [...value]
+        : [];
+}
+/** Load the bounded receipt-validation and deterministic-decision settings. */
+export function personalGlossaryCandidateDecisionContract(pathname = glossaryEntryAuthorityPath()) {
+    const authority = loadYamlMappingFile(pathname);
+    const candidateContracts = mapping(authority.candidate_contracts);
+    const layers = mapping(candidateContracts?.layers);
+    const decision = mapping(layers?.cli_decision);
+    const command = mapping(decision?.command);
+    const request = mapping(command?.request);
+    const result = mapping(command?.result);
+    const receiptConstruction = mapping(command?.receipt_construction);
+    const receiptConstructionResult = mapping(receiptConstruction?.result);
+    const automatic = mapping(decision?.automatic_admission);
+    const reasonCodesByOutcome = mapping(decision?.reason_codes_by_outcome);
+    if (!reasonCodesByOutcome || !hasGlossaryAdmissionReasonCodesByOutcome(reasonCodesByOutcome)) {
+        throw new TypeError("invalid development command projection: personal glossary decision outcome/reason authority is unavailable");
+    }
+    return {
+        command: projectGlossaryDevelopmentValue(command?.canonical, "candidate_decision.command"),
+        requestSchemaVersion: typeof request?.schema_version === "string" ? request.schema_version : "",
+        requestFields: strings(request?.required_fields),
+        maxRequestUtf8Bytes: typeof request?.max_utf8_bytes === "number" ? request.max_utf8_bytes : 0,
+        resultSchemaVersion: typeof result?.schema_version === "string" ? result.schema_version : "",
+        resultFields: strings(result?.fields),
+        resultStatuses: strings(result?.statuses),
+        reasonCodesByOutcome: Object.fromEntries(Object.entries(reasonCodesByOutcome).map(([outcome, reasons]) => [outcome, strings(reasons)])),
+        maxResultUtf8Bytes: typeof result?.max_utf8_bytes === "number" ? result.max_utf8_bytes : 0,
+        receiptConstructionRequestSchemaVersion: typeof receiptConstruction?.schema_version === "string"
+            ? receiptConstruction.schema_version
+            : "",
+        receiptConstructionRequestFields: strings(receiptConstruction?.required_fields),
+        receiptConstructionMaxRequestUtf8Bytes: typeof receiptConstruction?.max_utf8_bytes === "number"
+            ? receiptConstruction.max_utf8_bytes
+            : 0,
+        receiptConstructionResultSchemaVersion: typeof receiptConstructionResult?.schema_version === "string"
+            ? receiptConstructionResult.schema_version
+            : "",
+        receiptConstructionResultFields: strings(receiptConstructionResult?.fields),
+        receiptConstructionResultStatuses: strings(receiptConstructionResult?.statuses),
+        receiptConstructionMaxResultUtf8Bytes: typeof receiptConstructionResult?.max_utf8_bytes === "number"
+            ? receiptConstructionResult.max_utf8_bytes
+            : 0,
+        automaticProvenance: typeof automatic?.allowed_provenance === "string" ? automatic.allowed_provenance : "",
+        inferredAutomaticAdmission: typeof automatic?.inferred_automatic_admission === "string"
+            ? automatic.inferred_automatic_admission
+            : "",
+        qualityGate: typeof automatic?.quality_gate === "string" ? automatic.quality_gate : "",
+    };
+}

package/dist/registries/glossaryCandidateProjectionAuthority.js

@@ -0,0 +1,197 @@
+function mapping(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function strings(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+}
+function sameStrings(actual, expected) {
+    return JSON.stringify(strings(actual)) === JSON.stringify(expected);
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/** Validate the authority-owned bounds for the internal candidate projection. */
+export function validatePersonalCandidateProjectionAuthority(authority) {
+    const mining = mapping(authority.personal_mining_authority);
+    const projection = mapping(mining?.candidate_projection);
+    const selection = mapping(projection?.selection);
+    const sourceFamilies = mapping(selection?.source_families);
+    const projectIdentity = mapping(selection?.project_identity);
+    const excerpts = mapping(projection?.excerpts);
+    const excerptCompatibility = mapping(excerpts?.compatibility);
+    const retention = mapping(projection?.retention);
+    const persistence = mapping(projection?.persistence);
+    const retrieval = mapping(mining?.candidate_retrieval);
+    const currentGeneration = mapping(retrieval?.current_generation);
+    const retrievalCommand = mapping(retrieval?.command);
+    const list = mapping(retrieval?.list);
+    const filters = mapping(list?.filters);
+    const cursor = mapping(list?.cursor);
+    const safeContextView = mapping(retrieval?.safe_context_view);
+    const exact = mapping(retrieval?.exact);
+    const occurrence = mapping(exact?.occurrence);
+    const privacy = mapping(mining?.privacy);
+    const contentExclusion = mapping(privacy?.content_exclusion);
+    const storageFilesystem = mapping(mapping(privacy?.storage)?.filesystem);
+    if (projection?.status !== "active" ||
+        projection?.runtime !==
+            "packages/cli/src/analytics/personalGlossaryCandidateProjection.ts#projectPersonalGlossaryCandidates" ||
+        projection?.schema_version !== "agentera.personalGlossaryCandidateProjection.v1" ||
+        projection?.owner !== "deterministic_discovery_projection" ||
+        !nonEmpty(projection?.input) ||
+        !nonEmpty(projection?.output) ||
+        !nonEmpty(projection?.implementation_boundary) ||
+        selection?.candidates_max !== 50 ||
+        selection?.project_ids_max_per_candidate !== 100 ||
+        !sameStrings(Object.keys(sourceFamilies ?? {}), ["explicit", "recurring"]) ||
+        !sameStrings(sourceFamilies?.explicit, ["personal_explicit_definition"]) ||
+        !sameStrings(sourceFamilies?.recurring, [
+            "personal_inferred_usage",
+            "personal_inferred_conversation",
+        ]) ||
+        selection?.algorithm !== "least_retained_source_family_then_project_then_canonical_candidate" ||
+        selection?.tie_break !== "candidate_id_then_candidate_revision_then_capsule_sha256" ||
+        projectIdentity?.schema_version !== "agentera.personalGlossaryProjectionProjectIdentity.v1" ||
+        projectIdentity?.algorithm !== "sha256" ||
+        projectIdentity?.input !== "canonical_utf8_json_of_exact_transient_project_id" ||
+        projectIdentity?.output !== "lowercase_hex" ||
+        !nonEmpty(projectIdentity?.rule) ||
+        !nonEmpty(selection?.coverage) ||
+        excerpts?.source_max_utf8_bytes !== 4096 ||
+        excerpts?.max_per_candidate !== 1 ||
+        excerpts?.authority !== "personal_mining_authority.privacy.excerpts" ||
+        excerpts?.input_rule !== "candidate_adjacent_text_must_contain_the_exact_candidate_term" ||
+        !sameStrings(excerpts?.output_fields, ["text", "expires_at", "redacted"]) ||
+        excerptCompatibility?.redacted_field !== "retained_for_v1_consumers" ||
+        excerptCompatibility?.new_projection_value !== false ||
+        !sameStrings(excerpts?.omission_reasons, [
+            "no_excerpt",
+            "unrelated_context",
+            "source_bound_exceeded",
+            "unsafe_tool_arguments",
+            "unsafe_content",
+        ]) ||
+        !nonEmpty(excerpts?.rule) ||
+        retention?.authority !== "personal_mining_authority.privacy.retention" ||
+        retention?.purge !== "personal_mining_authority.privacy.purge" ||
+        !nonEmpty(retention?.rule) ||
+        persistence?.root !== "$AGENTERA_PROFILE_DIR/intermediate/personal-glossary" ||
+        persistence?.file !== "candidate-projection.json" ||
+        persistence?.canonicalization !== "candidate_contracts.canonicalization" ||
+        !sameStrings(persistence?.fields, [
+            "schema_version",
+            "owner",
+            "generation",
+            "policy_version",
+            "retained_at",
+            "candidates",
+            "report",
+            "projection_sha256",
+        ]) ||
+        persistence?.replay !== "byte_identical_projection_is_unchanged_replay" ||
+        persistence?.project_storage !== "forbidden" ||
+        persistence?.public_reads !== "forbidden" ||
+        !sameStrings(persistence?.private_machine_reads, ["candidate_retrieval", "cli_decision"]) ||
+        persistence?.review_disposition_writes !== "forbidden" ||
+        retrieval?.status !== "active" ||
+        retrieval?.owner !== "private_user_local_candidate_retrieval" ||
+        retrieval?.runtime !==
+            "packages/cli/src/cli/commands/personalGlossaryCandidateReads.ts#runPersonalGlossaryCandidateReadsCommand" ||
+        retrieval?.input !==
+            "current_validated_user_local_candidate_projection_bound_to_current_tier_generation" ||
+        currentGeneration?.source !== "current.json_readable_bounded_evidence_tier_generation" ||
+        currentGeneration?.projection_generation !== "exact_match_required" ||
+        currentGeneration?.unavailable_behavior !== "current_generation_unavailable" ||
+        currentGeneration?.stale_projection_behavior !== "projection_stale" ||
+        !nonEmpty(retrieval?.rule) ||
+        retrievalCommand?.canonical !==
+            "npx -y agentera@next report personal-glossary-candidates" ||
+        retrievalCommand?.namespace !== "report" ||
+        retrievalCommand?.format !== "json" ||
+        retrievalCommand?.project_checkout !== "not_required" ||
+        list?.schema_version !== "agentera.personalGlossaryCandidateRetrieval.v1" ||
+        list?.default_limit !== 20 ||
+        list?.maximum_limit !== 50 ||
+        list?.max_serialized_utf8_bytes !== 32768 ||
+        list?.order !== "candidate_id_then_candidate_revision_then_capsule_sha256" ||
+        list?.projection_binding_field !== "candidate_projection_sha256" ||
+        !sameStrings(filters?.source_family, ["explicit", "recurring"]) ||
+        filters?.provenance_kind_from !== "candidate_projection.selection.source_families" ||
+        !sameStrings(filters?.scope, ["personal", "ambiguous"]) ||
+        cursor?.authority !==
+            "references/artifacts/state-storage-authority.yaml#entity_target.public_retrieval.policy.cursor" ||
+        cursor?.vocabulary !== "opaque_snapshot_cursor" ||
+        !sameStrings(cursor?.binding, [
+            "collection",
+            "generation",
+            "policy_version",
+            "filters",
+            "limit",
+            "order",
+            "snapshot",
+        ]) ||
+        cursor?.invalid_behavior !== "cursor_invalid" ||
+        cursor?.unavailable_behavior !== "cursor_snapshot_unavailable" ||
+        !nonEmpty(list?.summaries) ||
+        !nonEmpty(list?.abstentions) ||
+        !nonEmpty(list?.coverage) ||
+        safeContextView?.authority !== "personal_mining_authority.privacy.retention" ||
+        safeContextView?.retention_days !== 30 ||
+        safeContextView?.expiry !== "expires_at_lte_read_time_is_unavailable" ||
+        safeContextView?.mutation !== "forbidden" ||
+        safeContextView?.snapshot !== "effective_availability_bound_to_opaque_cursor_snapshot" ||
+        !nonEmpty(safeContextView?.rule) ||
+        exact?.schema_version !== "agentera.personalGlossaryCandidateRetrieval.v1" ||
+        !sameStrings(exact?.required_bindings, [
+            "candidate_id",
+            "candidate_revision",
+            "generation",
+            "policy_version",
+        ]) ||
+        exact?.projection_binding_field !== "candidate_projection_sha256" ||
+        exact?.occurrences_max !== 100 ||
+        exact?.safe_context_max_utf8_bytes !== 500 ||
+        exact?.max_serialized_utf8_bytes !== 32768 ||
+        occurrence?.schema_version !== "agentera.personalGlossaryCandidateOccurrence.v1" ||
+        occurrence?.identity !== "opaque_sha256_of_validated_evidence_and_candidate_binding" ||
+        !sameStrings(occurrence?.allowed_fields, [
+            "occurrence_id",
+            "source_kind",
+            "signal_type",
+            "author_class",
+        ]) ||
+        !nonEmpty(exact?.rule) ||
+        contentExclusion?.owner !== "glossary_content_policy" ||
+        contentExclusion?.classification !== "actual_secret_or_sensitive_value" ||
+        contentExclusion?.conceptual_terminology !== "eligible" ||
+        !sameStrings(contentExclusion?.candidate_fields, ["term", "meaning"]) ||
+        contentExclusion?.candidate_action !== "reject_before_projection" ||
+        contentExclusion?.candidate_reason !== "secret_content" ||
+        contentExclusion?.excerpt_action !== "omit_complete_excerpt_before_projection" ||
+        !sameStrings(contentExclusion?.secret_classes, [
+            "api_keys",
+            "access_tokens",
+            "passwords",
+            "cookies",
+            "private_keys",
+            "authorization_headers",
+            "personal_contact_data",
+            "session_identifiers",
+            "runtime_store_paths",
+        ]) ||
+        !nonEmpty(contentExclusion?.rule) ||
+        storageFilesystem?.authority !== "host_filesystem" ||
+        storageFilesystem?.configured_path !== "use_as_provided" ||
+        storageFilesystem?.outcomes !== "ordinary_permissions_and_io" ||
+        storageFilesystem?.same_user_path_manipulation !== "outside_agentera_threat_model" ||
+        storageFilesystem?.symlink_confinement !== "not_claimed" ||
+        !nonEmpty(storageFilesystem?.rule) ||
+        !nonEmpty(persistence?.rule)) {
+        return [
+            "personal_mining_authority candidate projection must bound deterministic allocation, private retrieval, content exclusion, safe excerpts, host-filesystem storage, retention, and user-local replay",
+        ];
+    }
+    return [];
+}

package/dist/registries/glossaryCandidateProjectionContract.js

@@ -0,0 +1,104 @@
+import { loadYamlMappingFile } from "../core/yaml.js";
+import { projectGlossaryDevelopmentValue } from "../core/developmentInvocation.js";
+import { glossaryEntryAuthorityPath } from "./glossaryEntryContract.js";
+function mapping(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function strings(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string")
+        ? [...value]
+        : [];
+}
+/** Load the internal projection settings from the glossary authority. */
+export function personalGlossaryCandidateProjectionContract(pathname = glossaryEntryAuthorityPath()) {
+    const authority = loadYamlMappingFile(pathname);
+    const mining = mapping(authority.personal_mining_authority);
+    const projection = mapping(mining?.candidate_projection);
+    const selection = mapping(projection?.selection);
+    const excerpts = mapping(projection?.excerpts);
+    const privacy = mapping(mining?.privacy);
+    const contentExclusion = mapping(privacy?.content_exclusion);
+    const retention = mapping(privacy?.retention);
+    const projectIdentity = mapping(selection?.project_identity);
+    const persistence = mapping(projection?.persistence);
+    const families = mapping(selection?.source_families);
+    const sourceFamilies = Object.fromEntries(Object.entries(families ?? {}).flatMap(([family, values]) => Array.isArray(values) && values.every((value) => typeof value === "string")
+        ? [[family, [...values]]]
+        : []));
+    const retrieval = mapping(mining?.candidate_retrieval);
+    const currentGeneration = mapping(retrieval?.current_generation);
+    const retrievalCommand = mapping(retrieval?.command);
+    const list = mapping(retrieval?.list);
+    const filters = mapping(list?.filters);
+    const cursor = mapping(list?.cursor);
+    const exact = mapping(retrieval?.exact);
+    const safeContextView = mapping(retrieval?.safe_context_view);
+    return {
+        schemaVersion: typeof projection?.schema_version === "string" ? projection.schema_version : "",
+        owner: typeof projection?.owner === "string" ? projection.owner : "",
+        candidatesMax: typeof selection?.candidates_max === "number" ? selection.candidates_max : 0,
+        projectIdsMaxPerCandidate: typeof selection?.project_ids_max_per_candidate === "number"
+            ? selection.project_ids_max_per_candidate
+            : 0,
+        sourceExcerptMaxUtf8Bytes: typeof excerpts?.source_max_utf8_bytes === "number" ? excerpts.source_max_utf8_bytes : 0,
+        pendingExcerptDays: typeof retention?.pending_excerpt_days === "number" ? retention.pending_excerpt_days : 0,
+        sourceFamilies,
+        selectionAlgorithm: typeof selection?.algorithm === "string" ? selection.algorithm : "",
+        tieBreak: typeof selection?.tie_break === "string" ? selection.tie_break : "",
+        projectIdentitySchemaVersion: typeof projectIdentity?.schema_version === "string" ? projectIdentity.schema_version : "",
+        storageFile: typeof persistence?.file === "string" ? persistence.file : "",
+        candidateSecretReason: typeof contentExclusion?.candidate_reason === "string"
+            ? contentExclusion.candidate_reason
+            : "",
+        excerptSensitiveContentAction: typeof contentExclusion?.excerpt_action === "string" ? contentExclusion.excerpt_action : "",
+        candidateReadCommand: projectGlossaryDevelopmentValue(retrievalCommand?.canonical, "candidate_retrieval.command"),
+        candidateReadSchemaVersion: typeof list?.schema_version === "string" ? list.schema_version : "",
+        candidateReadDefaultLimit: typeof list?.default_limit === "number" ? list.default_limit : 0,
+        candidateReadMaximumLimit: typeof list?.maximum_limit === "number" ? list.maximum_limit : 0,
+        candidateReadOrder: typeof list?.order === "string" ? list.order : "",
+        candidateReadListProjectionBindingField: typeof list?.projection_binding_field === "string" ? list.projection_binding_field : "",
+        candidateReadSourceFamilies: Object.keys(sourceFamilies),
+        candidateReadProvenanceKinds: [
+            ...new Set(Object.values(sourceFamilies).flat()),
+        ].sort(),
+        candidateReadScopes: strings(filters?.scope),
+        candidateReadMaxSerializedUtf8Bytes: typeof list?.max_serialized_utf8_bytes === "number"
+            ? list.max_serialized_utf8_bytes
+            : 0,
+        candidateReadCursorVocabulary: typeof cursor?.vocabulary === "string" ? cursor.vocabulary : "",
+        candidateReadCursorBinding: strings(cursor?.binding),
+        candidateReadCursorInvalidBehavior: typeof cursor?.invalid_behavior === "string" ? cursor.invalid_behavior : "",
+        candidateReadCursorUnavailableBehavior: typeof cursor?.unavailable_behavior === "string"
+            ? cursor.unavailable_behavior
+            : "",
+        candidateReadExactRequiredBindings: strings(exact?.required_bindings),
+        candidateReadExactProjectionBindingField: typeof exact?.projection_binding_field === "string" ? exact.projection_binding_field : "",
+        candidateReadExactOccurrencesMax: typeof exact?.occurrences_max === "number" ? exact.occurrences_max : 0,
+        candidateReadSafeContextMaxUtf8Bytes: typeof exact?.safe_context_max_utf8_bytes === "number"
+            ? exact.safe_context_max_utf8_bytes
+            : 0,
+        candidateReadExactMaxSerializedUtf8Bytes: typeof exact?.max_serialized_utf8_bytes === "number"
+            ? exact.max_serialized_utf8_bytes
+            : 0,
+        candidateReadCursorAuthority: typeof cursor?.authority === "string" ? cursor.authority : "",
+        candidateReadSafeContextViewAuthority: typeof safeContextView?.authority === "string" ? safeContextView.authority : "",
+        candidateReadSafeContextRetentionDays: typeof safeContextView?.retention_days === "number"
+            ? safeContextView.retention_days
+            : 0,
+        candidateReadSafeContextViewExpiry: typeof safeContextView?.expiry === "string" ? safeContextView.expiry : "",
+        candidateReadSafeContextViewMutation: typeof safeContextView?.mutation === "string" ? safeContextView.mutation : "",
+        candidateReadSafeContextViewSnapshot: typeof safeContextView?.snapshot === "string" ? safeContextView.snapshot : "",
+        candidateReadCurrentGenerationSource: typeof currentGeneration?.source === "string" ? currentGeneration.source : "",
+        candidateReadCurrentGenerationProjectionBinding: typeof currentGeneration?.projection_generation === "string"
+            ? currentGeneration.projection_generation
+            : "",
+        candidateReadCurrentGenerationUnavailableBehavior: typeof currentGeneration?.unavailable_behavior === "string"
+            ? currentGeneration.unavailable_behavior
+            : "",
+        candidateReadCurrentGenerationStaleProjectionBehavior: typeof currentGeneration?.stale_projection_behavior === "string"
+            ? currentGeneration.stale_projection_behavior
+            : "",
+    };
+}

package/dist/registries/glossaryCaveatContract.js

@@ -0,0 +1,67 @@
+import { loadYamlMappingFile } from "../core/yaml.js";
+import { glossaryEntryAuthorityPath } from "./glossaryEntryContract.js";
+function mapping(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function strings(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+}
+function fixedValues(value) {
+    const source = mapping(value);
+    if (!source)
+        return {};
+    return Object.fromEntries(Object.entries(source).filter((entry) => typeof entry[1] === "string" || entry[1] === null));
+}
+function allowedPairs(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((candidate) => {
+        const pair = mapping(candidate);
+        return typeof pair?.reason === "string" && typeof pair.ownership_state === "string"
+            ? [{ reason: pair.reason, ownershipState: pair.ownership_state }]
+            : [];
+    });
+}
+export function glossaryCaveatPairAllowed(contract, reason, ownershipState) {
+    return contract.allowedCurrentPairs.some((pair) => pair.reason === reason && pair.ownershipState === ownershipState);
+}
+export function glossaryCaveatContract(pathname = glossaryEntryAuthorityPath()) {
+    return glossaryCaveatContractFromDocument(loadYamlMappingFile(pathname));
+}
+export function glossaryCaveatContractFromDocument(authority) {
+    const caveat = mapping(mapping(authority.consumer_boundary)?.autonomous_caveat);
+    const identity = mapping(caveat?.identity);
+    const envelope = mapping(caveat?.envelope);
+    const currentAppend = mapping(envelope?.current_append);
+    const primeProjection = mapping(caveat?.prime_projection);
+    const primeSource = mapping(primeProjection?.source);
+    const primeCapacity = mapping(primeProjection?.capacity);
+    return {
+        fields: strings(envelope?.fields),
+        currentAppendCallerFields: strings(currentAppend?.caller_fields),
+        currentAppendCallerFixedValues: Object.fromEntries(Object.entries(fixedValues(currentAppend?.caller_fixed_values)).filter((entry) => typeof entry[1] === "string")),
+        currentAppendWriterFields: strings(currentAppend?.writer_fields),
+        currentAppendWriterFixedValues: fixedValues(currentAppend?.writer_fixed_values),
+        events: strings(envelope?.events),
+        capabilities: strings(envelope?.capabilities),
+        reasons: strings(envelope?.reasons),
+        ownershipStates: strings(envelope?.ownership_states),
+        allowedCurrentPairs: allowedPairs(caveat?.allowed_current_pairs),
+        idAlphabet: typeof identity?.alphabet === "string" ? identity.alphabet : "",
+        idLength: typeof identity?.length === "number" ? identity.length : 0,
+        idPattern: new RegExp(typeof identity?.pattern === "string" ? identity.pattern : "a^"),
+        maxStringUtf8Bytes: typeof envelope?.max_string_utf8_bytes === "number" ? envelope.max_string_utf8_bytes : 0,
+        primeAttentionText: typeof primeProjection?.attention_text === "string" ? primeProjection.attention_text : "",
+        primeSourceArtifact: typeof primeSource?.artifact === "string" ? primeSource.artifact : "",
+        primeSourceBoundary: typeof primeSource?.boundary === "string" ? primeSource.boundary : "",
+        primeSourceCapability: typeof primeSource?.capability === "string" ? primeSource.capability : "",
+        primePublicAttentionLimit: typeof primeCapacity?.public_attention_limit === "number"
+            ? primeCapacity.public_attention_limit
+            : 0,
+        primeReservedGlossarySlots: typeof primeCapacity?.reserved_glossary_slots === "number"
+            ? primeCapacity.reserved_glossary_slots
+            : 0,
+    };
+}