agentera 3.0.0-dev.72 → 3.0.0-dev.74

package/dist/eval/glossaryEvaluationSuccessReport.js

@@ -0,0 +1,297 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveSourceRoot } from "../core/sourceRoot.js";
+import { canonicalDigest, GLOSSARY_EVALUATION_SCHEMA_VERSION, GLOSSARY_METRIC_IDS, glossaryEvaluationAuthorityPath, glossaryEvaluationBehaviorFixturePath, glossaryEvaluationCaseCounts, glossaryEvaluationHoldoutPath, glossaryEvaluationLabelDigest, loadGlossaryEvaluationAuthority, loadGlossaryEvaluationBehaviorFixture, loadGlossaryEvaluationHoldout, mapping, metricRule, sha256, validateFrozenGlossaryBehaviorFixture, validateFrozenGlossaryHoldout, validateGlossaryEvaluationAuthority, wilsonLowerBound, } from "./glossaryEvaluation.js";
+const MAX_SUCCESS_REPORT_UTF8_BYTES = 1_048_576;
+const POLICY_PATH = "references/artifacts/glossary-entry-contract.yaml";
+const SUCCESS_REPORT_FIELDS = [
+    "schemaVersion",
+    "status",
+    "report",
+    "authority",
+    "policy",
+    "holdout",
+    "behavior_fixture",
+    "observations",
+    "metrics",
+    "metrics_sha256",
+    "gates",
+    "denominator_counts",
+];
+function record(value) {
+    return mapping(value);
+}
+function exactFields(value, expected) {
+    const fields = Object.keys(value);
+    return fields.length === expected.length && expected.every((field) => Object.hasOwn(value, field));
+}
+function same(value, expected) {
+    try {
+        return canonicalDigest(value) === canonicalDigest(expected);
+    }
+    catch {
+        return false;
+    }
+}
+function isLowerSha256(value) {
+    return typeof value === "string" && /^[a-f0-9]{64}$/u.test(value);
+}
+function nonNegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function positiveInteger(value) {
+    return nonNegativeInteger(value) && value > 0;
+}
+function probability(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function currentBindings(root) {
+    try {
+        const authorityPath = glossaryEvaluationAuthorityPath(root);
+        const holdoutPath = glossaryEvaluationHoldoutPath(root);
+        const behaviorPath = glossaryEvaluationBehaviorFixturePath(root);
+        const authorityBytes = fs.readFileSync(authorityPath);
+        const holdoutBytes = fs.readFileSync(holdoutPath);
+        const behaviorBytes = fs.readFileSync(behaviorPath);
+        const authority = loadGlossaryEvaluationAuthority(root);
+        const holdout = loadGlossaryEvaluationHoldout(root);
+        const behavior = loadGlossaryEvaluationBehaviorFixture(root);
+        if (validateGlossaryEvaluationAuthority(authority).length > 0 ||
+            validateFrozenGlossaryHoldout(authority, holdout, holdoutBytes).length > 0 ||
+            validateFrozenGlossaryBehaviorFixture(authority, holdout, behavior, behaviorBytes).length > 0) {
+            return null;
+        }
+        return {
+            authority,
+            authorityBytes,
+            holdout,
+            holdoutBytes,
+            behavior,
+            behaviorBytes,
+            policyBytes: fs.readFileSync(path.join(root, POLICY_PATH)),
+            holdoutCaseCounts: glossaryEvaluationCaseCounts(holdout),
+            behaviorCaseCounts: glossaryEvaluationCaseCounts(behavior),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function passedMetric(value, expectedMetric, authority) {
+    const source = record(value);
+    if (source === null || source.metric !== expectedMetric)
+        return null;
+    const uncertainty = record(source.uncertainty);
+    const thresholds = record(source.thresholds);
+    const gates = record(source.gates);
+    if (uncertainty === null || thresholds === null || gates === null)
+        return null;
+    const numerator = source.numerator;
+    const denominator = source.denominator;
+    const pointEstimate = source.point_estimate;
+    const lowerBound = uncertainty.lower_bound;
+    const rule = metricRule(authority, expectedMetric);
+    if (!nonNegativeInteger(numerator) ||
+        !positiveInteger(denominator) ||
+        numerator > denominator ||
+        !probability(pointEstimate) ||
+        !probability(lowerBound) ||
+        pointEstimate !== numerator / denominator ||
+        lowerBound !== wilsonLowerBound(numerator, denominator, rule.confidence) ||
+        denominator < rule.minimumSampleSize ||
+        pointEstimate < rule.pointEstimateMinimum ||
+        lowerBound < rule.lowerBoundMinimum ||
+        uncertainty.method !== rule.uncertaintyMethod ||
+        uncertainty.confidence !== rule.confidence ||
+        uncertainty.one_sided !== true ||
+        thresholds.minimum_sample_size !== rule.minimumSampleSize ||
+        thresholds.point_estimate_minimum !== rule.pointEstimateMinimum ||
+        thresholds.lower_bound_minimum !== rule.lowerBoundMinimum ||
+        gates.denominator_nonzero !== true ||
+        gates.sample_sufficient !== true ||
+        gates.point_threshold !== true ||
+        gates.uncertainty_threshold !== true ||
+        source.status !== "pass" ||
+        !Array.isArray(source.failure_reasons) ||
+        source.failure_reasons.length !== 0) {
+        return null;
+    }
+    const metric = {
+        metric: expectedMetric,
+        numerator,
+        denominator,
+        point_estimate: pointEstimate,
+        uncertainty: {
+            method: rule.uncertaintyMethod,
+            confidence: rule.confidence,
+            one_sided: true,
+            lower_bound: lowerBound,
+        },
+        thresholds: {
+            minimum_sample_size: rule.minimumSampleSize,
+            point_estimate_minimum: rule.pointEstimateMinimum,
+            lower_bound_minimum: rule.lowerBoundMinimum,
+        },
+        gates: {
+            denominator_nonzero: true,
+            sample_sufficient: true,
+            point_threshold: true,
+            uncertainty_threshold: true,
+        },
+        status: "pass",
+        failure_reasons: [],
+    };
+    return same(source, metric) ? metric : null;
+}
+function validObservationSeams(value, counts) {
+    const seams = Array.isArray(value) ? value : null;
+    const expected = [
+        ["discovery_recall", "discovery", "mineExplicitGlossaryCandidates", false],
+        ["scope_accuracy", "scope", "mineExplicitGlossaryCandidates", true],
+        ["inferred_review_precision", "inferred_review", "mineRecurringGlossaryCandidates+personalGlossaryDecision.v2", false],
+        ["explicit_admission_precision", "explicit_admission", "mineExplicitGlossaryCandidates+personalGlossaryDecision.v2", false],
+    ];
+    if (seams === null || seams.length !== expected.length)
+        return false;
+    return expected.every(([metric, family, producer, hasAbstentions], index) => {
+        const seam = record(seams[index]);
+        if (seam === null || !exactFields(seam, hasAbstentions
+            ? ["metric", "producer", "cases", "candidates", "abstentions"]
+            : ["metric", "producer", "cases", "candidates"]))
+            return false;
+        const candidates = seam.candidates;
+        const abstentions = seam.abstentions;
+        return seam.metric === metric &&
+            seam.producer === producer &&
+            seam.cases === counts[family] &&
+            nonNegativeInteger(candidates) &&
+            candidates <= counts[family] &&
+            (!hasAbstentions || (nonNegativeInteger(abstentions) &&
+                candidates + abstentions <= counts[family]));
+    });
+}
+function validBindings(source, bindings) {
+    const expectedAuthority = {
+        schema_version: bindings.authority.schema_version,
+        path: "references/analysis/personal-glossary-evaluation-authority.yaml",
+        sha256: sha256(bindings.authorityBytes),
+    };
+    const expectedPolicy = { path: POLICY_PATH, sha256: sha256(bindings.policyBytes) };
+    const expectedHoldout = {
+        id: bindings.holdout.holdout_id,
+        status: bindings.holdout.status,
+        fixture_sha256: sha256(bindings.holdoutBytes),
+        labels_sha256: glossaryEvaluationLabelDigest(bindings.holdout),
+        provenance: bindings.holdout.provenance,
+        case_counts: bindings.holdoutCaseCounts,
+    };
+    const expectedBehavior = {
+        id: bindings.behavior.fixture_id,
+        status: bindings.behavior.status,
+        path: "references/analysis/personal-glossary-evaluation-corpus.yaml",
+        fixture_sha256: sha256(bindings.behaviorBytes),
+        provenance: bindings.behavior.provenance,
+        case_counts: bindings.behaviorCaseCounts,
+    };
+    const observations = record(source.observations);
+    return same(source.authority, expectedAuthority) &&
+        same(source.policy, expectedPolicy) &&
+        same(source.holdout, expectedHoldout) &&
+        same(source.behavior_fixture, expectedBehavior) &&
+        observations !== null &&
+        exactFields(observations, [
+            "schema_version",
+            "source",
+            "sha256",
+            "holdout_fixture_sha256",
+            "behavior_fixture_sha256",
+            "case_counts",
+            "seams",
+            "effects",
+        ]) &&
+        observations.schema_version === "agentera.personalGlossaryEvaluationObservations.v2" &&
+        observations.source === "current_product_behavior" &&
+        isLowerSha256(observations.sha256) &&
+        observations.holdout_fixture_sha256 === expectedHoldout.fixture_sha256 &&
+        observations.behavior_fixture_sha256 === expectedBehavior.fixture_sha256 &&
+        same(observations.case_counts, bindings.holdoutCaseCounts) &&
+        same(observations.effects, []) &&
+        validObservationSeams(observations.seams, bindings.holdoutCaseCounts);
+}
+function validReleaseReport(source, metrics) {
+    const expectedReport = {
+        exploratory: { release_authorizing: false, status: "report_only", metrics },
+        release_gate: {
+            release_authorizing: true,
+            release_authorized: true,
+            status: "pass",
+            failure_reasons: [],
+        },
+    };
+    const expectedGates = {
+        explicit_admission: {
+            metric: "explicit_admission_precision",
+            status: "pass",
+            qualification_blocker: true,
+            outcome: "explicit_automatic_admission_only",
+        },
+        inferred_review: {
+            metric: "inferred_review_precision",
+            status: "pass",
+            outcome: "review_suggestions_only",
+        },
+        inferred_automatic_admission: {
+            status: "disabled",
+            enabled: false,
+            measured_result: "cannot_enable",
+        },
+        release_authorizing: "pass",
+    };
+    const denominatorCounts = Object.fromEntries(metrics.map(({ metric, denominator }) => [metric, denominator]));
+    return same(source.report, expectedReport) &&
+        same(source.gates, expectedGates) &&
+        same(source.denominator_counts, denominatorCounts);
+}
+/**
+ * Accept only the current, complete, successful glossary evaluator report.
+ * This parser reads authority inputs but never imports or runs the evaluator.
+ */
+export function validateGlossaryEvaluationSuccessReport(result, root = resolveSourceRoot()) {
+    if (result.returncode !== 0 || Buffer.byteLength(result.stdout, "utf8") > MAX_SUCCESS_REPORT_UTF8_BYTES) {
+        return null;
+    }
+    let source;
+    try {
+        source = record(JSON.parse(result.stdout));
+    }
+    catch {
+        return null;
+    }
+    if (source === null ||
+        !exactFields(source, SUCCESS_REPORT_FIELDS) ||
+        source.schemaVersion !== GLOSSARY_EVALUATION_SCHEMA_VERSION ||
+        source.status !== "pass") {
+        return null;
+    }
+    const bindings = currentBindings(root);
+    if (bindings === null || !validBindings(source, bindings))
+        return null;
+    const sourceMetrics = source.metrics;
+    if (!Array.isArray(sourceMetrics) || sourceMetrics.length !== GLOSSARY_METRIC_IDS.length)
+        return null;
+    const metrics = [];
+    for (const [index, metric] of GLOSSARY_METRIC_IDS.entries()) {
+        const passed = passedMetric(sourceMetrics[index], metric, bindings.authority);
+        if (passed === null)
+            return null;
+        metrics.push(passed);
+    }
+    const metricsSha256 = source.metrics_sha256;
+    if (!isLowerSha256(metricsSha256) ||
+        metricsSha256 !== canonicalDigest(metrics) ||
+        canonicalDigest(sourceMetrics) !== canonicalDigest(metrics) ||
+        !validReleaseReport(source, metrics)) {
+        return null;
+    }
+    return { metrics, metrics_sha256: metricsSha256 };
+}

package/dist/registries/activationTuples.js

@@ -80,6 +80,34 @@ const addedTuples = [
     { class: "state", surface_id: "write:todo.repair", owner_path: "packages/cli/src/state/write/runtimeOperations.ts", owner_symbol_or_selector: "runtimeOperationSpecs", owner_selector: "todo.repair", semantic_selector_if_any: null, canonical_correction: "node packages/cli/dist/bin/agentera.js check validate state --format json" },
     { class: "package", surface_id: "emitted:packages/cli/src/cli/commands/doctor.ts", owner_path: "packages/cli/src/registries/packageRegistry.ts", owner_symbol_or_selector: "loadRegistry", owner_selector: "packages/cli/src/cli/commands/doctor.ts", semantic_selector_if_any: JSON.stringify({ path: "packages/cli/src/cli/commands/doctor.ts", selector: null, format: null, classification: null, reason: "Doctor project-state signals publish bounded reconciliation preview and apply guidance." }), canonical_correction: "pnpm -C packages/cli run verify:package" },
     { class: "package", surface_id: "emitted:packages/cli/src/state/todoReconciliationInspection.ts", owner_path: "packages/cli/src/registries/packageRegistry.ts", owner_symbol_or_selector: "loadRegistry", owner_selector: "packages/cli/src/state/todoReconciliationInspection.ts", semantic_selector_if_any: JSON.stringify({ path: "packages/cli/src/state/todoReconciliationInspection.ts", selector: null, format: null, classification: null, reason: "TODO reconciliation inspection publishes bounded preview and effect-bound apply guidance." }), canonical_correction: "pnpm -C packages/cli run verify:package" },
+    { class: "package", surface_id: "generated:build-source-identity", owner_path: "packages/cli/src/registries/packageRegistry.ts", owner_symbol_or_selector: "loadRegistry", owner_selector: ".agentera-build-source.json", semantic_selector_if_any: JSON.stringify({ path: ".agentera-build-source.json", selector: null, format: "json", classification: "active", reason: "Build-generated source identity binds constructed dist and bundle output to one Git commit, tree, and exact working-tree digest; no source copy exists." }), canonical_correction: "pnpm -C packages/cli run verify:package" },
+    {
+        class: "reference",
+        surface_id: "references/analysis/personal-glossary-evaluation-authority.yaml",
+        owner_path: "packages/cli/src/eval/glossaryEvaluation.ts",
+        owner_symbol_or_selector: "loadGlossaryEvaluationAuthority",
+        owner_selector: "references/analysis/personal-glossary-evaluation-authority.yaml",
+        semantic_selector_if_any: null,
+        canonical_correction: "node packages/cli/dist/bin/agentera.js check validate retained-references --format json",
+    },
+    {
+        class: "reference",
+        surface_id: "references/analysis/personal-glossary-holdout.yaml",
+        owner_path: "packages/cli/src/eval/glossaryEvaluation.ts",
+        owner_symbol_or_selector: "loadGlossaryEvaluationHoldout",
+        owner_selector: "references/analysis/personal-glossary-holdout.yaml",
+        semantic_selector_if_any: null,
+        canonical_correction: "node packages/cli/dist/bin/agentera.js check validate retained-references --format json",
+    },
+    {
+        class: "reference",
+        surface_id: "references/analysis/personal-glossary-evaluation-corpus.yaml",
+        owner_path: "packages/cli/src/eval/glossaryEvaluation.ts",
+        owner_symbol_or_selector: "loadGlossaryEvaluationBehaviorFixture",
+        owner_selector: "references/analysis/personal-glossary-evaluation-corpus.yaml",
+        semantic_selector_if_any: null,
+        canonical_correction: "node packages/cli/dist/bin/agentera.js check validate retained-references --format json",
+    },
 ];
 const tuples = [...rawTuples, ...addedTuples].map((tuple) => {
     const reason = emittedReasons[tuple.surface_id];
@@ -95,12 +123,12 @@ export const ACTIVATION_TUPLE_AUTHORITY = Object.freeze({
         cli: { count: 27, sha256: "9d0db6cafe592da30ea3469c91dc514bdd1b3b22e8229a0519e680cbcb01c2fa" },
         capability: { count: 12, sha256: "892e6e5e2a57b41064bc44fa2946453225f1b1195aff77aad05365fd0a1071c2" },
         runtime: { count: 81, sha256: "99b2abff3ebff889b54b1781c563ab4b32609a479c4e90d6aad854f48fba7edc" },
-        reference: { count: 22, sha256: "243fd3c317553f8924c56a52c61af90ccf2793b7b0018af1373b73c69b6c3afb" },
+        reference: { count: 25, sha256: "2a40b8a8585933417a6e66a350c9ad68050288600cdac1e7f44b914e7022565c" },
         state: { count: 38, sha256: "697de8dcd13ac521124c35058ba222aa5cb6cae546f00bb54652ceaca4b662aa" },
-        package: { count: 66, sha256: "83e6971af7f7564e42369aaccc445b32a0793bfffade843d149b6abd4fd3dbbc" },
+        package: { count: 67, sha256: "5dbe325af5ffb29a1ea50534070d08fcff647d4d9ef5654b4ce03d76eeaa8adb" },
         bootstrap: { count: 34, sha256: "9a7dd7e27110d85cf5c08835fdd8f08119e75579858e63bc6d396c733961d0bc" },
     },
-    total: { count: 280, sha256: "cd9396b45a82383e2f58da851f00061fa4c23c504ba9f41cf9fd7c7c39b0b092" },
+    total: { count: 284, sha256: "6b0d109f9d833598dcd1ec5b21cbc57e80ee8f21a0e5b61ca8aa420c6d32eb60" },
 });
 export function canonicalTupleJson(value) { return JSON.stringify(value); }
 export function digestCanonicalTuples(values) {

package/dist/registries/evidenceTierContract.js

@@ -25,6 +25,10 @@ export const REQUIRED_SIGNAL_KINDS = [
     "record_identity",
     "date",
     "evidence_anchor",
+    "session_id",
+    "origin_id",
+    "content_fingerprint",
+    "author_class",
 ];
 /** Compatibility states that must have deterministic, actionable outcomes. */
 export const REQUIRED_COMPATIBILITY_STATES = [