agentera 3.0.0-dev.8 → 3.0.0-dev.81

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,345 @@
+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;
+}
+const EXPLICIT_ABSTENTION_KEYS = [
+    "attributed_quotation",
+    "ambiguous_reference",
+    "conflicting_meaning",
+    "empty_meaning",
+    "empty_term",
+    "example_context",
+    "hypothetical_definition",
+    "malformed_span",
+    "meaning_bound_exceeded",
+    "negated_definition",
+    "indirect_question",
+    "future_definition",
+    "project_only_scope",
+    "question_definition",
+    "retracted_definition",
+    "sarcasm_marker",
+    "stale_anchor",
+    "structural_fragment",
+    "term_bound_exceeded",
+    "unsafe_syntax",
+    "uncertain_scope",
+    "unresolved_anchor",
+    "provenance_incomplete",
+    "user_authorship_required",
+];
+const RECURRING_ABSTENTION_KEYS = [
+    "agent_only_evidence",
+    "copied_content",
+    "provenance_missing",
+    "insufficient_independent_origins",
+    "insufficient_projects",
+    "insufficient_sessions",
+    "conversation_evidence_incomplete",
+    "conversation_evidence_bound_exceeded",
+    "project_only_scope",
+    "noise_term",
+    "too_many_qualifying_origins",
+    "user_authorship_required",
+];
+/** 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 refreshProduction = mapping(projection?.refresh_production);
+    const refreshProjection = mapping(refreshProduction?.projection);
+    const refreshConcurrency = mapping(refreshProduction?.concurrency);
+    const refreshContender = mapping(refreshConcurrency?.contender);
+    const partialFailure = mapping(refreshProduction?.partial_failure);
+    const safeReplacement = mapping(refreshProduction?.safe_replacement);
+    const selection = mapping(projection?.selection);
+    const sourceFamilies = mapping(selection?.source_families);
+    const projectIdentity = mapping(selection?.project_identity);
+    const miningSummary = mapping(projection?.mining_summary);
+    const summaryReconciliation = mapping(miningSummary?.reconciliation);
+    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);
+    const malformedProjectionReplacementException = mapping(storageFilesystem?.malformed_candidate_projection_replacement_exception);
+    const errors = [];
+    if (refreshProduction?.status !== "active" ||
+        refreshProduction?.runtime !==
+            "packages/cli/src/analytics/personalGlossaryRefreshProjection.ts#produceCurrentPersonalGlossaryProjection" ||
+        refreshProduction?.trigger !== "explicit_consented_evidence_refresh_success" ||
+        refreshProjection?.count !== "exactly_one" ||
+        refreshProjection?.generation_binding !== "exact_published_evidence_generation" ||
+        refreshProjection?.policy_binding !== "exact_personal_mining_policy_version" ||
+        !nonEmpty(refreshProduction?.rule)) {
+        errors.push("personal_mining_authority refresh production must require one projection bound to the exact evidence generation and mining policy");
+    }
+    if (refreshConcurrency?.serialization !== "profile_local_exclusive_refresh_commit" ||
+        refreshConcurrency?.lock_lifetime !==
+            "before_evidence_publication_through_projection_binding_verification" ||
+        refreshContender?.refresh_outcome !== "failure" ||
+        refreshContender?.process_exit !== "nonzero" ||
+        refreshContender?.local_history_read !== false ||
+        refreshContender?.tier_write !== false ||
+        refreshContender?.projection_status !== "failed" ||
+        refreshContender?.projection_write !== false ||
+        refreshContender?.evidence_status !== "current_generation_remains_readable" ||
+        refreshContender?.recovery !== "npx -y agentera@next report refresh --consent local-history") {
+        errors.push("personal_mining_authority refresh production must serialize evidence and projection commit and fail contenders without writes");
+    }
+    if (partialFailure?.refresh_outcome !== "failure" ||
+        partialFailure?.process_exit !== "nonzero" ||
+        partialFailure?.evidence_status !== "published" ||
+        partialFailure?.projection_status !== "failed" ||
+        partialFailure?.tier_write_reporting !== "evidence_published_projection_not_written" ||
+        partialFailure?.current_generation !== "published_evidence_remains_current") {
+        errors.push("personal_mining_authority refresh production must report evidence and projection outcomes separately and preserve published evidence on projection failure");
+    }
+    if (safeReplacement?.authorization !== "explicit_consented_refresh_only" ||
+        safeReplacement?.target !== "exact_configured_candidate_projection_file" ||
+        safeReplacement?.precondition !== "existing_owned_regular_file_is_malformed" ||
+        safeReplacement?.operation !== "atomic_regular_file_replacement" ||
+        !sameStrings(safeReplacement?.reject, [
+            "symlink",
+            "non_regular_file",
+            "configured_path_mismatch",
+            "path_escape",
+        ]) ||
+        safeReplacement?.filesystem_exception !==
+            "personal_mining_authority.privacy.storage.filesystem.malformed_candidate_projection_replacement_exception" ||
+        !sameStrings(safeReplacement?.replaceable_state, ["candidate_projection"]) ||
+        !sameStrings(safeReplacement?.preserved_state, [
+            "current_evidence_generation",
+            "review_records",
+            "personal_profile",
+            "project_state",
+            "project_glossary",
+        ])) {
+        errors.push("personal_mining_authority refresh replacement must target only the exact owned regular projection and preserve evidence, review, profile, and project state");
+    }
+    if (malformedProjectionReplacementException?.scope !==
+        "malformed_candidate_projection_replacement_only" ||
+        malformedProjectionReplacementException?.authorization !== "explicit_consented_refresh_only" ||
+        malformedProjectionReplacementException?.precondition !==
+            "existing_owned_regular_file_is_malformed" ||
+        malformedProjectionReplacementException?.target !==
+            "exact_configured_candidate_projection_file" ||
+        malformedProjectionReplacementException?.inspection !==
+            "lstat_exact_target_without_following_symlinks" ||
+        malformedProjectionReplacementException?.required_type !== "regular_file" ||
+        !sameStrings(malformedProjectionReplacementException?.reject, [
+            "symlink",
+            "non_regular_file",
+            "configured_path_mismatch",
+            "path_escape",
+        ]) ||
+        malformedProjectionReplacementException?.operation !== "atomic_regular_file_replacement" ||
+        malformedProjectionReplacementException?.outside_scope !== "configured_path_use_as_provided") {
+        errors.push("personal_mining_authority filesystem exception must confine malformed projection replacement to the exact configured regular file with no-follow inspection");
+    }
+    if (miningSummary?.schema_version !== "agentera.personalGlossaryMiningSummary.v1" ||
+        miningSummary?.location !== "report.mining_summary" ||
+        !sameStrings(miningSummary?.family_fields, [
+            "candidate_count",
+            "abstention_count",
+            "abstentions_by_reason",
+        ]) ||
+        !sameStrings(miningSummary?.explicit_abstention_keys, EXPLICIT_ABSTENTION_KEYS) ||
+        !sameStrings(miningSummary?.recurring_abstention_keys, RECURRING_ABSTENTION_KEYS) ||
+        summaryReconciliation?.fixed_keys !== "all_keys_present_as_nonnegative_integers" ||
+        summaryReconciliation?.family_abstentions !== "abstention_count_equals_sum_of_reason_counts" ||
+        summaryReconciliation?.total_candidates !==
+            "total_equals_explicit_plus_recurring_candidate_counts" ||
+        summaryReconciliation?.total_abstentions !==
+            "total_equals_explicit_plus_recurring_abstention_counts" ||
+        summaryReconciliation?.projection_input !== "report_input_count_equals_total_candidate_count" ||
+        !sameStrings(miningSummary?.forbidden_content, [
+            "terms",
+            "source_ids",
+            "evidence_anchors",
+            "project_ids",
+            "project_keys",
+            "paths",
+            "excerpts",
+        ]) ||
+        !nonEmpty(miningSummary?.rule)) {
+        errors.push("personal_mining_authority candidate projection must retain reconciled fixed-key aggregate mining counts without sensitive identity or content");
+    }
+    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)) {
+        errors.push("personal_mining_authority candidate projection must bound deterministic allocation, private retrieval, content exclusion, safe excerpts, host-filesystem storage, retention, and user-local replay");
+    }
+    return errors;
+}

package/dist/registries/glossaryCandidateProjectionContract.js

@@ -0,0 +1,108 @@
+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 miningSummary = mapping(projection?.mining_summary);
+    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 : "",
+        miningSummarySchemaVersion: typeof miningSummary?.schema_version === "string" ? miningSummary.schema_version : "",
+        explicitAbstentionKeys: strings(miningSummary?.explicit_abstention_keys),
+        recurringAbstentionKeys: strings(miningSummary?.recurring_abstention_keys),
+        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
+            : "",
+    };
+}