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

package/dist/cli/commands/prime/briefOrientation.js

@@ -281,7 +281,10 @@ function briefHistory(history, projection = "normal") {
             projected.caveats = caveats;
         if (isObject(entryObj.degraded_history)) {
             const degraded = pick(entryObj.degraded_history, ["summary_count", "returned_count", "omitted_count"]);
-            degraded.retrieval = briefHistoryRetrieval(entryObj.degraded_history.retrieval);
+            // Compact routing already retains the same exact list/get commands on the
+            // parent history entry. Keep the nested copy only in the normal brief.
+            if (projection === "normal")
+                degraded.retrieval = briefHistoryRetrieval(entryObj.degraded_history.retrieval);
             const degradedCaveats = briefHistoryCaveats(entryObj.degraded_history.caveats, maxChars);
             if (degradedCaveats !== undefined)
                 degraded.caveats = degradedCaveats;
@@ -389,20 +392,94 @@ function briefDecisionAttention(attention) {
         : [];
     return out;
 }
-function briefDocs(docs) {
-    // No default-bare consumer reads the docs projection detail. Keep the
-    // availability signal and mapping count; the verbose source_contract with
-    // state_families recovers via the canonical docs list fallback.
-    return pick(docs, ["exists", "status", "mapping_entries", "indexed_documents"]);
+function briefDocsRetrieval(value, maxChars) {
+    const out = {};
+    if (isObject(value)) {
+        for (const key of ["list", "get", "exact", "detail_command"]) {
+            const command = boundedString(value[key], maxChars);
+            if (command !== undefined)
+                out[key] = command;
+        }
+    }
+    return out;
+}
+function briefDocEntry(value, maxChars) {
+    if (!isObject(value))
+        return {};
+    const out = pick(value, ["id", "artifact"]);
+    const source = isObject(value.record) ? value.record : value;
+    const record = {};
+    for (const key of ["document", "path", "last_updated", "status"]) {
+        const bounded = boundedString(source[key], maxChars);
+        if (bounded !== undefined)
+            record[key] = bounded;
+    }
+    const recordCaveats = briefHistoryCaveats(source.caveats, maxChars);
+    if (recordCaveats !== undefined)
+        record.caveats = recordCaveats;
+    if (Object.keys(record).length > 0)
+        out.record = record;
+    const caveats = briefHistoryCaveats(value.caveats, maxChars);
+    if (caveats !== undefined)
+        out.caveats = caveats;
+    const retrieval = briefDocsRetrieval(value.retrieval, maxChars);
+    if (Object.keys(retrieval).length > 0)
+        out.retrieval = retrieval;
+    return out;
 }
-function briefProgress(progress) {
+function briefDocs(docs, projection = "normal") {
+    if (!isObject(docs))
+        return {};
+    const maxChars = projectionMaxChars(projection);
+    const entryLimit = projection === "normal" ? 3 : 1;
+    const out = pick(docs, ["exists", "status", "last_audit", "mapping_entries", "indexed_documents"]);
+    const absenceReason = boundedString(docs.absence_reason, maxChars);
+    if (absenceReason !== undefined)
+        out.absence_reason = absenceReason;
+    const caveats = briefHistoryCaveats(docs.caveats, maxChars);
+    if (caveats !== undefined)
+        out.caveats = caveats;
+    const sourceEntries = Array.isArray(docs.entries) ? docs.entries : null;
+    let detailAvailability = Number(docs.mapping_entries) > 0 || Number(docs.indexed_documents) > 0
+        ? "summary"
+        : "full";
+    if (sourceEntries) {
+        const entries = sourceEntries.slice(0, entryLimit).map((entry) => briefDocEntry(entry, maxChars));
+        const declaredTotal = Number(docs.indexed_documents);
+        const total = Number.isSafeInteger(declaredTotal) && declaredTotal >= entries.length
+            ? declaredTotal
+            : sourceEntries.length;
+        out.counts = { total, returned: entries.length, remaining: Math.max(0, total - entries.length) };
+        out.entries = entries;
+        detailAvailability = total > entries.length ? "summary" : "full";
+    }
+    const sourceContract = isObject(docs.source_contract)
+        ? pick(docs.source_contract, ["detail_availability", "raw_artifact_reads_required", "capability_startup_complete", "inventory_authority"])
+        : {};
+    sourceContract.detail_availability = detailAvailability;
+    sourceContract.retrieval = STATE_FAMILY_FALLBACK_COMMANDS.docs;
+    out.source_contract = sourceContract;
+    return out;
+}
+function briefDegradedHistory(value, omitRetrieval) {
+    if (!isObject(value))
+        return undefined;
+    if (!omitRetrieval)
+        return { ...value };
+    const out = pick(value, ["status", "summary_count", "returned_count", "omitted_count", "caveats"]);
+    return out;
+}
+function briefProgress(progress, omitDegradedRetrieval = false) {
     // opencode reads progress.latest.number/what/next; the brief keeps the
     // latest cycle but caps free-text scalars at BRIEF_SCALAR_MAX_CHARS so a
     // pathological value cannot blow the budget. Full detail recovers via
     // `agentera state progress get --id ID --format json`.
     if (!isObject(progress))
         return {};
-    const out = pick(progress, ["exists", "status", "latest_verification", "cycle_count", "degraded_history"]);
+    const out = pick(progress, ["exists", "status", "latest_verification", "cycle_count"]);
+    const degradedHistory = briefDegradedHistory(progress.degraded_history, omitDegradedRetrieval);
+    if (degradedHistory !== undefined)
+        out.degraded_history = degradedHistory;
     const latest = progress.latest;
     if (isObject(latest)) {
         const boundedLatest = {};
@@ -416,8 +493,22 @@ function briefProgress(progress) {
     }
     return out;
 }
-function briefHealth(health) {
-    return pick(health, ["exists", "id", "artifact", "date", "trajectory", "grade", "degraded_history"]);
+function briefHealth(health, omitDegradedRetrieval = false) {
+    const out = pick(health, ["exists", "id", "artifact", "date", "trajectory", "grade"]);
+    if (isObject(health)) {
+        const degradedHistory = briefDegradedHistory(health.degraded_history, omitDegradedRetrieval);
+        if (degradedHistory !== undefined)
+            out.degraded_history = degradedHistory;
+    }
+    return out;
+}
+function hasCanonicalHistoryRetrieval(history, artifact) {
+    if (!isObject(history) || !isObject(history[artifact]))
+        return false;
+    const retrieval = history[artifact].retrieval;
+    return isObject(retrieval)
+        && typeof retrieval.list === "string" && retrieval.list.length > 0
+        && typeof retrieval.get === "string" && retrieval.get.length > 0;
 }
 function briefAction(action, maxChars) {
     if (!isObject(action))
@@ -562,10 +653,10 @@ function projectBriefBody(payload) {
                 out[key] = briefSharedSkill(value);
                 break;
             case "progress":
-                out[key] = briefProgress(value);
+                out[key] = briefProgress(value, hasCanonicalHistoryRetrieval(payload.history, "progress"));
                 break;
             case "health":
-                out[key] = briefHealth(value);
+                out[key] = briefHealth(value, hasCanonicalHistoryRetrieval(payload.history, "health"));
                 break;
             case "next_action":
                 out[key] = briefNextAction(value);
@@ -621,19 +712,27 @@ function degradedBody(payload, projection) {
         out.project_integration = briefProjectIntegration(payload.project_integration);
     if ("todo_reconciliation" in payload)
         out.todo_reconciliation = payload.todo_reconciliation;
-    if ("startup" in payload)
-        out.startup = payload.startup;
+    if ("startup" in payload) {
+        // The top-level reconciliation object is the canonical bare-prime route.
+        // Do not repeat it inside startup when compacting an over-budget envelope.
+        const startup = isObject(payload.startup) ? { ...payload.startup } : payload.startup;
+        if (isObject(startup) && "todo_reconciliation" in out)
+            delete startup.todo_reconciliation;
+        out.startup = startup;
+    }
     if ("health" in payload)
-        out.health = briefHealth(payload.health);
+        out.health = briefHealth(payload.health, hasCanonicalHistoryRetrieval(payload.history, "health"));
     if ("todo" in payload)
         out.todo = payload.todo;
     if ("progress" in payload)
-        out.progress = briefProgress(payload.progress);
+        out.progress = briefProgress(payload.progress, hasCanonicalHistoryRetrieval(payload.history, "progress"));
     if ("attention" in payload)
         out.attention = briefAttention(payload.attention);
     if ("source" in payload)
         out.source = briefSource(payload.source);
-    for (const conditional of ["v1_migration", "docs", "objective"]) {
+    if ("docs" in payload)
+        out.docs = briefDocs(payload.docs, projection);
+    for (const conditional of ["v1_migration", "objective"]) {
         if (conditional in payload)
             out[conditional] = payload[conditional];
     }
@@ -711,8 +810,8 @@ function degradedBriefEnvelope(payload, budget, attemptedBytes, mode) {
         path_diagnostics_recovery: PATH_DIAGNOSTICS_RECOVERY,
         error: {
             class: "brief_output_budget",
-            message: "the projected decision brief exceeded the authority byte budget; compact recovery metadata was emitted",
-            recovery: `Run \`${preCutoverCommand("prime --context status --format json")}\` for status startup.`,
+            message: "brief exceeds byte budget",
+            recovery: `Run \`${preCutoverCommand("prime --context status --format json")}\`.`,
         },
     };
     const compact = settledBriefEnvelope(body("compact"), compactMeta);

package/dist/cli/commands/report.js

@@ -167,8 +167,24 @@ export function cmdReport(args, io = {}) {
             return 2;
         }
         if (!dryRun && consent !== "local-history") {
-            err("Error: agentera stats refresh requires explicit --consent local-history to read local runtime history. " +
-                "Preview first with agentera stats refresh --dry-run\n");
+            const recovery = "agentera report refresh --consent local-history";
+            const message = "Error: agentera stats refresh requires explicit --consent local-history to read local runtime history. " +
+                "Preview first with agentera stats refresh --dry-run";
+            if (outputFormat === "json") {
+                out(JSON.stringify({
+                    command: "stats refresh",
+                    status: "degraded_consent_required",
+                    recovery,
+                    privacy: {
+                        local_history_read: false,
+                        local_history_write: false,
+                        tier_write: false,
+                        required_consent: "local-history",
+                        provided_consent: consent,
+                    },
+                }, null, 2) + "\n");
+            }
+            err(`${message}\nRecovery: ${recovery}\n`);
             return 2;
         }
         const corpusPath = args.output || statsCorpusPath();

package/dist/cli/commands/schema.js

@@ -9,6 +9,9 @@ import { CANONICAL_SHARED_SKILL_PATH } from "../../setup/sharedSkill.js";
 import { loadStateRetrievalAuthority } from "../../state/retrievalAuthority.js";
 import { entityListFamilies } from "../../state/entityRetrievalHelp.js";
 import { personalGlossaryOutputContract } from "../../registries/glossaryEntryContract.js";
+import { personalGlossaryCandidateProjectionContract } from "../../registries/glossaryCandidateProjectionContract.js";
+import { personalGlossaryCandidateDecisionContract } from "../../registries/glossaryCandidateDecisionContract.js";
+import { personalGlossaryReviewRecordsContract } from "../../registries/glossaryReviewRecordsContract.js";
 import { describeArtifactSchemaFields } from "../../registries/artifactSchemaProjection.js";
 import { advertisedValidateFamilyNames } from "./validate.js";
 import { SCHEMA_TOP_LEVEL_COMMANDS } from "../dispatch/projections.js";
@@ -331,6 +334,9 @@ export function buildSchemaPayload(command = "schema") {
     gaps.push(...schemaGaps);
     const retrievalAuthority = loadStateRetrievalAuthority();
     const profileGlossary = personalGlossaryOutputContract();
+    const candidateReads = personalGlossaryCandidateProjectionContract();
+    const candidateDecision = personalGlossaryCandidateDecisionContract();
+    const reviewRecords = personalGlossaryReviewRecordsContract();
     const authorityPath = integrationAuthorityPath();
     return {
         schemaVersion: "agentera.schema.v1",
@@ -375,8 +381,181 @@ export function buildSchemaPayload(command = "schema") {
             personal_glossary: {
                 command: profileGlossary.command,
                 request_schema_version: profileGlossary.requestSchemaVersion,
+                request_fields: profileGlossary.requestFields,
+                request_optional_fields: profileGlossary.requestOptionalFields,
+                max_request_utf8_bytes: profileGlossary.maxRequestUtf8Bytes,
+                result_schema_version: profileGlossary.resultSchemaVersion,
+                result_fields: profileGlossary.resultFields,
+                max_result_utf8_bytes: profileGlossary.maxResultUtf8Bytes,
                 output_statuses: profileGlossary.outputStatuses,
+                review_authorization: {
+                    fields: profileGlossary.reviewAuthorizationFields,
+                    dispositions: profileGlossary.reviewAuthorizationDispositions,
+                },
                 project_checkout: "not_required",
+                candidate_retrieval: {
+                    command: candidateReads.candidateReadCommand,
+                    schema_version: candidateReads.candidateReadSchemaVersion,
+                    list: {
+                        default_limit: candidateReads.candidateReadDefaultLimit,
+                        maximum_limit: candidateReads.candidateReadMaximumLimit,
+                        max_serialized_utf8_bytes: candidateReads.candidateReadMaxSerializedUtf8Bytes,
+                        order: candidateReads.candidateReadOrder,
+                        projection_binding_field: candidateReads.candidateReadListProjectionBindingField,
+                        source_families: candidateReads.candidateReadSourceFamilies,
+                        provenance_kinds: candidateReads.candidateReadProvenanceKinds,
+                        scopes: candidateReads.candidateReadScopes,
+                        cursor: {
+                            authority: candidateReads.candidateReadCursorAuthority,
+                            vocabulary: candidateReads.candidateReadCursorVocabulary,
+                            binding: candidateReads.candidateReadCursorBinding,
+                            invalid_behavior: candidateReads.candidateReadCursorInvalidBehavior,
+                            unavailable_behavior: candidateReads.candidateReadCursorUnavailableBehavior,
+                        },
+                    },
+                    exact: {
+                        required_bindings: candidateReads.candidateReadExactRequiredBindings,
+                        projection_binding_field: candidateReads.candidateReadExactProjectionBindingField,
+                        occurrences_max: candidateReads.candidateReadExactOccurrencesMax,
+                        safe_context_max_utf8_bytes: candidateReads.candidateReadSafeContextMaxUtf8Bytes,
+                        max_serialized_utf8_bytes: candidateReads.candidateReadExactMaxSerializedUtf8Bytes,
+                    },
+                    safe_context_view: {
+                        authority: candidateReads.candidateReadSafeContextViewAuthority,
+                        retention_days: candidateReads.candidateReadSafeContextRetentionDays,
+                        expiry: candidateReads.candidateReadSafeContextViewExpiry,
+                        mutation: candidateReads.candidateReadSafeContextViewMutation,
+                        snapshot: candidateReads.candidateReadSafeContextViewSnapshot,
+                    },
+                    current_generation: {
+                        source: candidateReads.candidateReadCurrentGenerationSource,
+                        projection_generation: candidateReads.candidateReadCurrentGenerationProjectionBinding,
+                        unavailable_behavior: candidateReads.candidateReadCurrentGenerationUnavailableBehavior,
+                        stale_projection_behavior: candidateReads.candidateReadCurrentGenerationStaleProjectionBehavior,
+                    },
+                    project_checkout: "not_required",
+                },
+                candidate_decision: {
+                    command: candidateDecision.command,
+                    request_schema_version: candidateDecision.requestSchemaVersion,
+                    request_fields: candidateDecision.requestFields,
+                    max_request_utf8_bytes: candidateDecision.maxRequestUtf8Bytes,
+                    result_schema_version: candidateDecision.resultSchemaVersion,
+                    result_fields: candidateDecision.resultFields,
+                    statuses: candidateDecision.resultStatuses,
+                    reason_codes_by_outcome: candidateDecision.reasonCodesByOutcome,
+                    max_result_utf8_bytes: candidateDecision.maxResultUtf8Bytes,
+                    receipt_construction: {
+                        request_schema_version: candidateDecision.receiptConstructionRequestSchemaVersion,
+                        request_fields: candidateDecision.receiptConstructionRequestFields,
+                        max_request_utf8_bytes: candidateDecision.receiptConstructionMaxRequestUtf8Bytes,
+                        result_schema_version: candidateDecision.receiptConstructionResultSchemaVersion,
+                        result_fields: candidateDecision.receiptConstructionResultFields,
+                        statuses: candidateDecision.receiptConstructionResultStatuses,
+                        max_result_utf8_bytes: candidateDecision.receiptConstructionMaxResultUtf8Bytes,
+                    },
+                    automatic_admission: {
+                        allowed_provenance: candidateDecision.automaticProvenance,
+                        inferred_automatic_admission: candidateDecision.inferredAutomaticAdmission,
+                        quality_gate: candidateDecision.qualityGate,
+                    },
+                    project_checkout: "not_required",
+                    effects: [],
+                },
+                review_records: {
+                    command: reviewRecords.command,
+                    queue: {
+                        request_schema_version: reviewRecords.queueRequestSchemaVersion,
+                        request_fields: reviewRecords.queueRequestFields,
+                        max_request_utf8_bytes: reviewRecords.queueMaxRequestUtf8Bytes,
+                        decision_outcome: reviewRecords.queueDecisionOutcome,
+                        current_bindings: reviewRecords.queueCurrentBindings,
+                        result_schema_version: reviewRecords.queueResultSchemaVersion,
+                        statuses: reviewRecords.queueResultStatuses,
+                        max_result_utf8_bytes: reviewRecords.queueMaxResultUtf8Bytes,
+                        no_question_channel: reviewRecords.queueNoQuestionChannel,
+                    },
+                    disposition: {
+                        request_schema_version: reviewRecords.dispositionRequestSchemaVersion,
+                        request_fields: reviewRecords.dispositionRequestFields,
+                        max_request_utf8_bytes: reviewRecords.dispositionMaxRequestUtf8Bytes,
+                        result_schema_version: reviewRecords.dispositionResultSchemaVersion,
+                        statuses: reviewRecords.dispositionResultStatuses,
+                        max_result_utf8_bytes: reviewRecords.dispositionMaxResultUtf8Bytes,
+                        publication_authorization: {
+                            dispositions: reviewRecords.dispositionPublicationAuthorizationDispositions,
+                            fields: reviewRecords.dispositionPublicationAuthorizationFields,
+                        },
+                    },
+                    trusted_host_key: {
+                        file: reviewRecords.trustedHostKeyFile,
+                        schema_version: reviewRecords.trustedHostKeySchemaVersion,
+                        fields: reviewRecords.trustedHostKeyFields,
+                        owner: reviewRecords.trustedHostKeyOwner,
+                        public_key_algorithm: reviewRecords.trustedHostKeyAlgorithm,
+                        max_serialized_utf8_bytes: reviewRecords.trustedHostKeyMaxSerializedUtf8Bytes,
+                    },
+                    persistence: {
+                        schema_version: reviewRecords.storeSchemaVersion,
+                        record_schema_version: reviewRecords.recordSchemaVersion,
+                        owner: reviewRecords.storeOwner,
+                        file: reviewRecords.storeFile,
+                        fields: reviewRecords.storeFields,
+                        record_fields: reviewRecords.recordFields,
+                        records_max: reviewRecords.recordsMax,
+                        replay_index_fields: reviewRecords.replayIndexFields,
+                        replay_entries_max: reviewRecords.replayEntriesMax,
+                        record_max_serialized_utf8_bytes: reviewRecords.recordMaxSerializedUtf8Bytes,
+                        max_serialized_utf8_bytes: reviewRecords.storeMaxSerializedUtf8Bytes,
+                        replay: reviewRecords.replay,
+                        conflict: reviewRecords.conflict,
+                        compatibility: {
+                            accepted_store_schema_versions: reviewRecords.compatibilityStoreSchemaVersions,
+                            accepted_record_schema_versions: reviewRecords.compatibilityRecordSchemaVersions,
+                            read_mutation: reviewRecords.compatibilityReadMutation,
+                            migration_operation: reviewRecords.compatibilityMigrationOperation,
+                            scope_derivation: reviewRecords.compatibilityScopeDerivation,
+                            invalid_behavior: reviewRecords.compatibilityInvalidBehavior,
+                            preserved_bindings: reviewRecords.compatibilityPreservedBindings,
+                            legacy_digest: reviewRecords.compatibilityLegacyDigest,
+                            migrated_digest: reviewRecords.compatibilityMigratedDigest,
+                        },
+                        suppression_binding: reviewRecords.suppressionBinding,
+                        suppression_dispositions: reviewRecords.suppressionDispositions,
+                        reopen_reasons: reviewRecords.reopenReasons,
+                        forbidden_fields: reviewRecords.forbiddenFields,
+                    },
+                    retrieval: {
+                        schema_version: reviewRecords.retrievalSchemaVersion,
+                        owner: reviewRecords.retrievalOwner,
+                        list: {
+                            default_limit: reviewRecords.listDefaultLimit,
+                            maximum_limit: reviewRecords.listMaximumLimit,
+                            max_serialized_utf8_bytes: reviewRecords.listMaxSerializedUtf8Bytes,
+                            order: reviewRecords.listOrder,
+                            statuses: reviewRecords.listStatuses,
+                            cursor: {
+                                authority: reviewRecords.cursorAuthority,
+                                vocabulary: reviewRecords.cursorVocabulary,
+                                binding: reviewRecords.cursorBinding,
+                                invalid_behavior: reviewRecords.cursorInvalidBehavior,
+                                unavailable_behavior: reviewRecords.cursorUnavailableBehavior,
+                            },
+                        },
+                        exact: {
+                            required_bindings: reviewRecords.exactRequiredBindings,
+                            current_binding_field: reviewRecords.exactCurrentBindingField,
+                            max_serialized_utf8_bytes: reviewRecords.exactMaxSerializedUtf8Bytes,
+                        },
+                    },
+                    maintenance: {
+                        terminal_metadata_days: reviewRecords.terminalMetadataDays,
+                        exposure: reviewRecords.maintenanceExposure,
+                        purge: reviewRecords.maintenancePurge,
+                        forbidden_effects: reviewRecords.maintenanceForbiddenEffects,
+                    },
+                    project_checkout: "not_required",
+                },
             },
             historical_import: {
                 source: "claude",

package/dist/cli/commands/verify.js

@@ -1,11 +1,13 @@
 import { main as evalSkillsMain } from "../../eval/evalSkills.js";
 import { main as semanticEvalMain } from "../../eval/semanticEval.js";
+import { runGlossaryEvaluationProcess } from "../../eval/glossaryEvaluationProcess.js";
+import { validateGlossaryEvaluationSuccessReport, } from "../../eval/glossaryEvaluationSuccessReport.js";
 import { evaluateHybridRoute } from "../../eval/hybridRouteEvaluation.js";
 import { routeEvaluationExitCode } from "./route.js";
 export const VERIFY_FAMILIES = ["eval"];
 export const RETIRED_VERIFY_FAMILIES = ["smoke"];
 export const VERIFY_TARGETS = {
-    eval: ["skills", "semantic", "routing"],
+    eval: ["skills", "semantic", "routing", "glossary"],
 };
 export const VERIFY_FORMATS = ["text", "json"];
 export const VERIFY_DIAGNOSTIC_LINE_LIMIT = 20;
@@ -63,15 +65,20 @@ export function validateVerifyRequest(args) {
     }
     if (family === "eval" && target === "semantic" && (args.fixtures ?? []).length === 0) {
         throw new Error("semantic verify requires explicit fixture path(s); broad fixture discovery is not a safe default. " +
-            "Valid targets for eval: skills, semantic. " +
+            "Valid targets for eval: skills, semantic, routing, glossary. " +
             "Syntax: agentera verify eval semantic <fixture> [<fixture>...] [--format text|json]. " +
             "Example: agentera verify eval semantic fixtures/semantic/bare-agentera-message.md --format json");
     }
+    if (family === "eval" && target === "glossary" && (args.fixtures ?? []).length > 0) {
+        throw new Error("glossary verify uses the contract-owned frozen holdout and accepts no fixture path. " +
+            "It always runs current product behavior. Syntax: agentera check verify eval glossary --format text|json.");
+    }
     return [family, target, outputFormat];
 }
 /**
- * Resolve the engine command + safety metadata for a verify target. eval engines
- * run in-process (ported TS). Only the eval family is supported; the smoke
+ * Resolve the engine command + safety metadata for a verify target. The frozen
+ * glossary evaluator runs in its isolated process so unrelated CLI starts do
+ * not load its mining graph. Only the eval family is supported; the smoke
  * family (maintainer/CI harnesses) was retired in the self-contained package.
  */
 function runVerifyEngine(family, target, args) {
@@ -117,6 +124,22 @@ function runVerifyEngine(family, target, args) {
         const result = runInProcess(["eval", "semantic", ...fixtures], (out) => semanticEvalMain(fixtures, (l) => out(l)));
         return { result, safety };
     }
+    if (family === "eval" && target === "glossary") {
+        const safety = {
+            mode: "offline-frozen-holdout",
+            summary: "runs frozen synthetic inputs through current glossary discovery, classification, and V2 decision seams without a semantic host or user-local effects",
+            live: false,
+            long_running_default: false,
+        };
+        const evaluation = runGlossaryEvaluationProcess();
+        const result = {
+            command: ["node", "agentera", "verify", "eval", "glossary"],
+            returncode: evaluation.returncode,
+            stdout: evaluation.stdout,
+            stderr: evaluation.stderr,
+        };
+        return { result, safety };
+    }
     if (family === "eval" && target === "routing") {
         const safety = {
             mode: "offline-frozen-corpus",
@@ -162,23 +185,42 @@ function boundedLines(text, limit = VERIFY_DIAGNOSTIC_LINE_LIMIT) {
         return lines;
     return [...lines.slice(0, limit), `... truncated ${lines.length - limit} line(s)`];
 }
+function publicVerifyResult(family, target, result) {
+    if (family !== "eval" || target !== "glossary" || result.returncode !== 0)
+        return { result };
+    const glossaryEvaluation = validateGlossaryEvaluationSuccessReport(result);
+    if (glossaryEvaluation !== null)
+        return { result, glossaryEvaluation };
+    const separator = result.stderr === "" || result.stderr.endsWith("\n") ? "" : "\n";
+    return {
+        result: {
+            ...result,
+            returncode: 1,
+            stderr: `${result.stderr}${separator}invalid glossary evaluation success report\n`,
+        },
+    };
+}
 function verifyStatus(result) {
     return result.returncode === 0 ? "pass" : "fail";
 }
 export function buildVerifyPayload(family, target, outputFormat, result, safety) {
+    const publicResult = publicVerifyResult(family, target, result);
     return {
         command: "verify",
-        status: verifyStatus(result),
+        status: verifyStatus(publicResult.result),
         family,
         target,
         format: outputFormat,
-        engine: { command: result.command, exit_code: result.returncode },
+        engine: { command: publicResult.result.command, exit_code: publicResult.result.returncode },
         diagnostics: {
-            stdout: boundedLines(result.stdout),
-            stderr: boundedLines(result.stderr),
+            stdout: boundedLines(publicResult.result.stdout),
+            stderr: boundedLines(publicResult.result.stderr),
             line_limit: VERIFY_DIAGNOSTIC_LINE_LIMIT,
         },
         safety,
+        ...(publicResult.glossaryEvaluation === undefined
+            ? {}
+            : { glossary_evaluation: publicResult.glossaryEvaluation }),
     };
 }
 function emitVerifyText(payload, out) {
@@ -221,5 +263,5 @@ export function cmdVerify(args, io = {}) {
     else {
         emitVerifyText(payload, out);
     }
-    return result.returncode;
+    return payload.engine.exit_code;
 }

package/dist/cli/dispatch/lifecycle.js

@@ -8,7 +8,10 @@ import { cmdVerify } from "../commands/verify.js";
 import { cmdGate } from "../commands/compact.js";
 import { cmdReport } from "../commands/report.js";
 import { runGlossaryAdviceCommand } from "../commands/glossaryAdvice.js";
-import { runPersonalGlossaryCommand } from "../commands/personalGlossary.js";
+import { runPersonalGlossaryPublishCommand } from "../commands/personalGlossaryPublish.js";
+import { runPersonalGlossaryCandidateReadsCommand } from "../commands/personalGlossaryCandidateReads.js";
+import { runPersonalGlossaryDecisionCommand } from "../commands/personalGlossaryDecision.js";
+import { runPersonalGlossaryReviewRecordsCommand } from "../commands/personalGlossaryReviewRecords.js";
 import { runProfileGroundingCommand } from "../commands/profileGrounding.js";
 import { preCutoverCommand } from "../preCutoverCommand.js";
 import { usageMain } from "../../analytics/usageStats.js";
@@ -442,6 +445,48 @@ export function runVerify(argv, io, prog) {
     }
 }
 export function runReport(argv, io, prog) {
+    if (argv[0] === "personal-glossary-decision") {
+        if (prog !== "agentera report") {
+            return emitInvalidInput(io, {
+                format: "json",
+                body: {
+                    class: "unsupported_target",
+                    message: "personal-glossary-decision has no stats alias",
+                    valid_values: ["report personal-glossary-decision"],
+                    recovery: `Run ${preCutoverCommand("report personal-glossary-decision --input - --format json")}; no bytes were changed.`,
+                },
+            });
+        }
+        return runPersonalGlossaryDecisionCommand(argv.slice(1), io);
+    }
+    if (argv[0] === "personal-glossary-candidates") {
+        if (prog !== "agentera report") {
+            return emitInvalidInput(io, {
+                format: "json",
+                body: {
+                    class: "unsupported_target",
+                    message: "personal-glossary-candidates has no stats alias",
+                    valid_values: ["report personal-glossary-candidates"],
+                    recovery: `Run ${preCutoverCommand("report personal-glossary-candidates list --limit 20 --format json")}; no projection bytes were changed.`,
+                },
+            });
+        }
+        return runPersonalGlossaryCandidateReadsCommand(argv.slice(1), io);
+    }
+    if (argv[0] === "personal-glossary-reviews") {
+        if (prog !== "agentera report") {
+            return emitInvalidInput(io, {
+                format: "json",
+                body: {
+                    class: "unsupported_target",
+                    message: "personal-glossary-reviews has no stats alias",
+                    valid_values: ["report personal-glossary-reviews"],
+                    recovery: `Run ${preCutoverCommand("report personal-glossary-reviews list --limit 20 --format json")}; no review metadata was changed.`,
+                },
+            });
+        }
+        return runPersonalGlossaryReviewRecordsCommand(argv.slice(1), io);
+    }
     if (argv[0] === "glossary-advice") {
         if (prog !== "agentera report") {
             return emitInvalidInput(io, {
@@ -470,19 +515,19 @@ export function runReport(argv, io, prog) {
         }
         return runProfileGroundingCommand(argv.slice(1), io);
     }
-    if (argv[0] === "profile-glossary") {
+    if (argv[0] === "personal-glossary-publish") {
         if (prog !== "agentera report") {
             return emitInvalidInput(io, {
                 format: "json",
                 body: {
                     class: "unsupported_target",
-                    message: "profile-glossary has no stats alias",
-                    valid_values: ["report profile-glossary"],
-                    recovery: `Run ${preCutoverCommand("report profile-glossary --input PATH --format json")} with the same input; no profile bytes were changed.`,
+                    message: "personal-glossary-publish has no stats alias",
+                    valid_values: ["report personal-glossary-publish"],
+                    recovery: `Run ${preCutoverCommand("report personal-glossary-publish --input - --format json")}; no profile bytes were changed.`,
                 },
             });
         }
-        return runPersonalGlossaryCommand(argv.slice(1), io);
+        return runPersonalGlossaryPublishCommand(argv.slice(1), io);
     }
     const args = {
         action: null,