agentera 3.0.0-dev.72 → 3.0.0-dev.75

package/dist/registries/glossaryEntryContract.js

@@ -3,6 +3,9 @@ import { projectGlossaryDevelopmentValue } from "../core/developmentInvocation.j
 import { resolveSourceRoot } from "../core/sourceRoot.js";
 import { loadYamlMappingFile } from "../core/yaml.js";
 import { validateConsumerBoundary, validateConsumerEvidenceOwner, } from "./glossaryConsumerContractValidation.js";
+import { validatePersonalCandidateContracts } from "./glossaryCandidateContracts.js";
+import { validateConversationProvenance, validateHistoryEvidence, validatePersonalMiningAuthority, validateProvenanceVariants, } from "./glossaryMiningAuthority.js";
+import { isGlossaryIsoCalendarDate } from "./glossaryEntryTemporal.js";
 export class GlossaryEntryBoundError extends Error {
 }
 const DEFERRED_CAPABILITIES = ["profile", "audit", "discuss", "plan", "build"];
@@ -24,10 +27,33 @@ export function personalGlossaryAdmissionContract(pathname = glossaryEntryAuthor
     const authority = contract(pathname);
     const personal = mapping(mapping(authority.ownership_contracts)?.personal);
     const admission = mapping(personal?.admission);
+    const conversation = mapping(mapping(authority.provenance_variants)?.personal_inferred_conversation);
+    const explicitVariant = mapping(mapping(authority.provenance_variants)?.personal_explicit_definition);
+    const explicitDiscovery = mapping(mapping(authority.personal_mining_authority)?.explicit_discovery);
+    const explicitGrammar = mapping(explicitDiscovery?.grammar);
+    const expectedEvidence = mapping(conversation?.expected_evidence);
     return {
         explicitSignalTypes: strings(mapping(admission?.explicit)?.candidate_signal_types),
+        explicitGrammarIds: (Array.isArray(explicitGrammar?.forms) ? explicitGrammar.forms : [])
+            .map((item) => mapping(item))
+            .filter((item) => item !== null)
+            .map((item) => String(item.id))
+            .filter(Boolean),
+        explicitProvenanceFields: strings(mapping(explicitVariant?.source_provenance)?.required_fields),
         inferredSignalTypes: strings(mapping(admission?.inferred)?.candidate_signal_types),
         inferredSourceKinds: strings(mapping(admission?.inferred)?.source_kinds),
+        conversationSignalTypes: strings(conversation?.allowed_signal_types),
+        conversationSourceKinds: strings(conversation?.allowed_source_kinds),
+        conversationAuthorClasses: strings(conversation?.allowed_author_classes),
+        conversationEvidenceFields: strings(conversation?.required_evidence_fields),
+        conversationExpectedEvidenceContextFields: strings(expectedEvidence?.context_fields),
+        conversationMinimumEvidenceCount: typeof conversation?.minimum_evidence_count === "number"
+            ? conversation.minimum_evidence_count
+            : 0,
+        conversationCompletenessAuthority: typeof conversation?.completeness_authority === "string"
+            ? conversation.completeness_authority
+            : "",
+        conversationAdmission: typeof conversation?.admission === "string" ? conversation.admission : "",
         insufficientRecovery: typeof admission?.insufficient_recovery === "string"
             ? admission.insufficient_recovery.trim()
             : "",
@@ -45,12 +71,22 @@ export function personalGlossaryOutputContract(pathname = glossaryEntryAuthority
     const output = mapping(personal?.profile_output);
     const command = mapping(output?.command);
     const request = mapping(command?.request);
+    const result = mapping(command?.result);
     const section = mapping(output?.section);
+    const reviewAuthorization = mapping(request?.review_authorization);
     return {
         command: projectGlossaryDevelopmentValue(command?.canonical, "profile_output.command"),
         requestSchemaVersion: typeof request?.schema_version === "string" ? request.schema_version : "",
+        requestFields: strings(request?.required_fields),
+        requestOptionalFields: strings(request?.optional_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),
+        maxResultUtf8Bytes: typeof result?.max_utf8_bytes === "number" ? result.max_utf8_bytes : 0,
         sectionSchemaVersion: typeof section?.document_schema_version === "string" ? section.document_schema_version : "",
         outputStatuses: strings(command?.output_statuses),
+        reviewAuthorizationFields: strings(reviewAuthorization?.required_fields),
+        reviewAuthorizationDispositions: strings(reviewAuthorization?.dispositions),
     };
 }
 export function personalProfileGroundingContract(pathname = glossaryEntryAuthorityPath()) {
@@ -119,19 +155,6 @@ export function isSafeProjectSourcePath(value) {
         !path.win32.isAbsolute(value) &&
         !value.split(/[\\/]/).includes(".."));
 }
-function isIsoCalendarDate(value) {
-    if (typeof value !== "string")
-        return false;
-    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
-    if (!match)
-        return false;
-    const [, year, month, day] = match.map(Number);
-    const date = new Date(`${value}T00:00:00.000Z`);
-    return (!Number.isNaN(date.getTime()) &&
-        date.getUTCFullYear() === year &&
-        date.getUTCMonth() + 1 === month &&
-        date.getUTCDate() === day);
-}
 export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityPath()) {
     let authority;
     try {
@@ -144,6 +167,8 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
     if (authority.schema_version !== "agentera.glossaryEntryContract.v1") {
         errors.push("schema_version must be agentera.glossaryEntryContract.v1");
     }
+    errors.push(...validatePersonalMiningAuthority(authority));
+    errors.push(...validatePersonalCandidateContracts(authority));
     const occurrence = mapping(authority.term_occurrence);
     if (occurrence?.runtime !==
         "packages/cli/src/registries/glossaryTermOccurrence.ts#containsGlossaryTerm" ||
@@ -201,51 +226,7 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
         errors.push("provenance must derive its kind and evidence variants from provenance_variants");
     }
     const variants = mapping(authority.provenance_variants);
-    const variantExpectations = {
-        personal_explicit_definition: {
-            owner: "personal",
-            evidence_count: 1,
-            required_evidence_fields: ["source_id", "evidence_anchor", "signal_type"],
-            allowed_signal_types: ["correction", "decision", "instruction"],
-        },
-        personal_inferred_usage: {
-            owner: "personal",
-            evidence_count: 2,
-            required_evidence_fields: ["source_id", "evidence_anchor", "source_kind"],
-            allowed_source_kinds: ["instruction_document", "project_config_signal"],
-        },
-        project_file: {
-            owner: "project",
-            evidence_count: 1,
-            required_evidence_fields: ["source_path", "source_record_sha256"],
-        },
-    };
-    for (const [kind, expectedVariant] of Object.entries(variantExpectations)) {
-        const variant = mapping(variants?.[kind]);
-        if (!variant) {
-            errors.push(`provenance variant ${kind} is required`);
-            continue;
-        }
-        if (variant.owner !== expectedVariant.owner)
-            errors.push(`${kind}.owner must be ${expectedVariant.owner}`);
-        if (variant.evidence_count !== expectedVariant.evidence_count) {
-            errors.push(`${kind}.evidence_count must be ${expectedVariant.evidence_count}`);
-        }
-        if (!sameStrings(variant.required_evidence_fields, expectedVariant.required_evidence_fields)) {
-            errors.push(`${kind}.required_evidence_fields must match its provenance variant`);
-        }
-        if (variant.additional_evidence_fields !== "forbidden") {
-            errors.push(`${kind}.additional_evidence_fields must be forbidden`);
-        }
-        for (const allowedField of ["allowed_signal_types", "allowed_source_kinds"]) {
-            if (allowedField in expectedVariant &&
-                !sameStrings(variant[allowedField], expectedVariant[allowedField])) {
-                errors.push(`${kind}.${allowedField} must preserve the admitted evidence classes`);
-            }
-        }
-        if (!nonEmpty(variant.resolution_rule))
-            errors.push(`${kind}.resolution_rule is required`);
-    }
+    errors.push(...validateProvenanceVariants(variants));
     const ownership = mapping(authority.ownership_contracts);
     const personal = mapping(ownership?.personal);
     if (personal?.scope !== "user")
@@ -253,6 +234,7 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
     if (!sameStrings(personal?.allowed_provenance, [
         "personal_explicit_definition",
         "personal_inferred_usage",
+        "personal_inferred_conversation",
     ])) {
         errors.push("personal ownership must admit only personal provenance variants");
     }
@@ -280,13 +262,19 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
     if (personalImplementation?.status !== "active_partial" ||
         !sameStrings(personalImplementation?.active, [
             "bounded_admission",
+            "bounded_explicit_discovery",
+            "bounded_candidate_projection",
+            "bounded_candidate_retrieval",
+            "public_receipt_construction",
+            "host_classification_receipt_validation",
+            "deterministic_cli_admission_decision",
             "explicit_classification",
             "inferred_evidence_check",
-            "profile_full_rendering",
-            "profile_persistence",
+            "authorized_personal_publication",
+            "profile_section_persistence",
         ]) ||
         !sameStrings(personalImplementation?.inactive, ["lookup"])) {
-        errors.push("personal rendering and persistence must be active_partial while lookup remains inactive");
+        errors.push("personal implementation must be active_partial while lookup remains inactive");
     }
     if (!sameStrings(mapping(admission?.explicit)?.candidate_signal_types, [
         "correction",
@@ -316,37 +304,36 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
         if (!nonEmpty(decay?.[field]))
             errors.push(`personal retention_and_decay.${field} is required`);
     }
-    const profileOutput = mapping(personal?.profile_output);
-    const profileSection = mapping(profileOutput?.section);
+    const profileOutput = mapping(personal?.profile_output), profileSection = mapping(profileOutput?.section);
     const mergeIdentity = mapping(profileOutput?.merge_identity);
-    const profileCommand = mapping(profileOutput?.command);
-    const profileRequest = mapping(profileCommand?.request);
-    if (profileOutput?.owner !== "profile_full" ||
-        profileOutput?.lifecycle_callable !==
-            "packages/cli/src/analytics/personalGlossaryProfile.ts#updatePersonalGlossaryProfile" ||
-        profileCommand?.canonical !== "npx -y agentera@next report profile-glossary" ||
+    const profileCommand = mapping(profileOutput?.command), profileRequest = mapping(profileCommand?.request), profileFilesystem = mapping(profileOutput?.filesystem);
+    const reviewAuthorization = mapping(profileRequest?.review_authorization);
+    if (profileOutput?.owner !== "personal_profile_publication" ||
+        profileOutput?.lifecycle_callable !== "packages/cli/src/analytics/personalGlossaryProfile.ts#updatePersonalGlossaryProfile" ||
+        profileCommand?.canonical !== "npx -y agentera@next report personal-glossary-publish" ||
         profileCommand?.namespace !== "report" ||
         profileCommand?.input_flag !== "--input" ||
         profileCommand?.stdin_value !== "-" ||
         profileCommand?.format !== "json" ||
         profileCommand?.dry_run_flag !== "--dry-run" ||
         profileCommand?.project_checkout !== "not_required" ||
-        profileRequest?.schema_version !== "agentera.personalGlossaryUpdateRequest.v1" ||
-        !sameStrings(profileRequest?.required_fields, [
-            "schema_version",
-            "profile_path",
-            "as_of",
-            "fresh_entries",
-            "retained_history",
-        ]) ||
+        profileRequest?.schema_version !== "agentera.personalGlossaryPublishRequest.v1" ||
+        !sameStrings(profileRequest?.required_fields, ["schema_version", "receipt", "decision", "as_of"]) ||
+        !sameStrings(profileRequest?.optional_fields, ["review_authorization"]) ||
         profileRequest?.additional_fields !== "forbidden" ||
+        profileRequest?.max_utf8_bytes !== 16384 ||
         !nonEmpty(profileRequest?.profile_path_rule) ||
-        !nonEmpty(profileRequest?.retained_history_shape) ||
-        !sameStrings(profileCommand?.output_statuses, [
-            "changed",
-            "unchanged_replay",
-            "dry_run_candidate",
-        ]) ||
+        !nonEmpty(profileRequest?.current_decision_rule) ||
+        !sameStrings(reviewAuthorization?.required_fields, ["review_id", "review_record_sha256"]) ||
+        reviewAuthorization?.additional_fields !== "forbidden" ||
+        !sameStrings(reviewAuthorization?.dispositions, ["accept", "correct"]) ||
+        reviewAuthorization?.source !== "personal_mining_authority.review_records.disposition.publication_authorization" ||
+        !nonEmpty(reviewAuthorization?.rule) ||
+        !nonEmpty(profileRequest?.date_rule) ||
+        mapping(profileCommand?.result)?.schema_version !==
+            "agentera.personalGlossaryPublicationResult.v1" ||
+        mapping(profileCommand?.result)?.max_utf8_bytes !== 4096 ||
+        !sameStrings(profileCommand?.output_statuses, ["changed", "unchanged_replay", "dry_run_candidate"]) ||
         !nonEmpty(profileCommand?.rule) ||
         profileSection?.heading !== "## Glossary" ||
         profileSection?.start_marker !== "<!-- agentera:personal-glossary:start -->" ||
@@ -360,7 +347,13 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
         !nonEmpty(mergeIdentity?.rule) ||
         !nonEmpty(profileOutput?.refresh_rule) ||
         !nonEmpty(profileOutput?.decay_rule) ||
-        !nonEmpty(profileOutput?.isolation_rule)) {
+        !nonEmpty(profileOutput?.isolation_rule) ||
+        profileFilesystem?.authority !== "host_filesystem" ||
+        profileFilesystem?.configured_path !== "canonical_user_profile_authority" ||
+        profileFilesystem?.outcomes !== "ordinary_permissions_and_io" ||
+        profileFilesystem?.same_user_path_manipulation !== "outside_agentera_threat_model" ||
+        profileFilesystem?.symlink_confinement !== "not_claimed" ||
+        !nonEmpty(profileFilesystem?.rule)) {
         errors.push("personal profile output must define deterministic isolated rendering and lifecycle rules");
     }
     const project = mapping(ownership?.project);
@@ -458,7 +451,8 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
         errors.push("project entry derivation must produce only the shared project_file primitive");
     }
     if (publication?.owner !== "build" ||
-        publication?.command !== "npx -y agentera@next state glossary publish --input REQUEST --format json" ||
+        publication?.command !==
+            "npx -y agentera@next state glossary publish --input REQUEST --format json" ||
         publicationRequest?.schema_version !== "agentera.glossaryPublicationRequest.v1" ||
         !sameStrings(publicationRequest?.required_fields, [
             "schema_version",
@@ -502,8 +496,21 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
         profileGrounding?.parser !==
             "packages/cli/src/analytics/personalGlossaryProfile.ts#personalProfileGrounding" ||
         profileGrounding?.max_profile_utf8_bytes !== 65536 ||
-        !sameStrings(mapping(profileGrounding?.validity)?.statuses, ["absent", "valid", "repair_needed"]) ||
-        !sameStrings(mapping(profileGrounding?.validity)?.classes, ["absent", "valid", "malformed", "ambiguous", "unreadable", "unsafe", "oversized", "invalid_utf8"]) ||
+        !sameStrings(mapping(profileGrounding?.validity)?.statuses, [
+            "absent",
+            "valid",
+            "repair_needed",
+        ]) ||
+        !sameStrings(mapping(profileGrounding?.validity)?.classes, [
+            "absent",
+            "valid",
+            "malformed",
+            "ambiguous",
+            "unreadable",
+            "unsafe",
+            "oversized",
+            "invalid_utf8",
+        ]) ||
         !sameStrings(mapping(profileGrounding?.freshness)?.states, ["current", "stale", "unknown"]) ||
         !nonEmpty(mapping(profileGrounding?.recovery)?.repair) ||
         !nonEmpty(mapping(profileGrounding?.recovery)?.absent) ||
@@ -532,15 +539,19 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
         !sameStrings(profile?.capabilities, ["profile"]) ||
         !sameStrings(profile?.active_behavior, [
             "ownership_contracts.personal.admission",
-            "ownership_contracts.personal.profile_output",
+            "personal_mining_authority.profile_full",
         ]) ||
         !sameStrings(profile?.inactive_behavior, ["lookup"]) ||
         profileContracts?.admission !== "ownership_contracts.personal.input" ||
         profileContracts?.provenance !== "ownership_contracts.personal.allowed_provenance" ||
         profileContracts?.confidence !== "shared_primitive.fields.confidence" ||
         profileContracts?.retention_and_decay !== "ownership_contracts.personal.retention_and_decay" ||
-        !sameStrings(profile?.forbidden_current_claims, ["lookup", "project_glossary_consumption"])) {
-        errors.push("profile glossary rendering and persistence must be active while Profile itself performs no consumer lookup");
+        profileContracts?.profile_full !== "personal_mining_authority.profile_full" ||
+        !sameStrings(profile?.forbidden_current_claims, [
+            "lookup",
+            "project_glossary_consumption",
+        ])) {
+        errors.push("profile glossary synthesis must reuse existing consented input and only canonical authorized personal publication");
     }
     const audit = mapping(capabilities?.audit);
     const findingFamily = mapping(audit?.finding_family);
@@ -647,7 +658,7 @@ function requiredEntryShape(entry, authority) {
     }
     const temporal = mapping(entry.temporal);
     for (const field of strings(mapping(fields?.temporal)?.required_fields)) {
-        if (!isIsoCalendarDate(temporal?.[field])) {
+        if (!isGlossaryIsoCalendarDate(temporal?.[field])) {
             errors.push(`temporal.${field} must be an ISO date`);
         }
     }
@@ -665,18 +676,6 @@ function evidenceShape(evidence, requiredFields, kind, index) {
     }
     return errors;
 }
-function validateHistoryEvidence(evidence, context, index) {
-    const errors = [];
-    const sourceId = typeof evidence.source_id === "string" ? evidence.source_id : "";
-    const anchor = typeof evidence.evidence_anchor === "string" ? evidence.evidence_anchor : "";
-    const retained = context.retainedHistory.get(anchor);
-    if (!sourceId || !anchor)
-        errors.push(`provenance.evidence[${index}] requires source_id and evidence_anchor`);
-    if (!retained || retained.sourceId !== sourceId) {
-        errors.push(`provenance.evidence[${index}].evidence_anchor must resolve to its retained source_id`);
-    }
-    return errors;
-}
 export function validateGlossaryEntry(entry, owner, context = { retainedHistory: new Map() }, pathname = glossaryEntryAuthorityPath()) {
     const authorityErrors = validateGlossaryEntryContract(pathname);
     if (authorityErrors.length > 0) {
@@ -738,6 +737,9 @@ export function validateGlossaryEntry(entry, owner, context = { retainedHistory:
             }
         }
     }
+    if (kind === "personal_inferred_conversation") {
+        errors.push(...validateConversationProvenance(evidence, provenance, variant, context));
+    }
     if (kind === "project_file") {
         if (evidence.length !== evidenceCount || evidence[0] === null) {
             errors.push("project file provenance requires exactly one source record");

package/dist/registries/glossaryEntryTemporal.js

@@ -0,0 +1,12 @@
+/** Validate a calendar date without accepting normalized JavaScript date overflow. */
+export function isGlossaryIsoCalendarDate(value) {
+    if (typeof value !== "string")
+        return false;
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(value);
+    if (!match)
+        return false;
+    const [, year, month, day] = match.map(Number);
+    const date = new Date(`${value}T00:00:00.000Z`);
+    return !Number.isNaN(date.getTime()) && date.getUTCFullYear() === year &&
+        date.getUTCMonth() + 1 === month && date.getUTCDate() === day;
+}