@holonograph/client 0.7.0 → 0.9.0

package/dist/index.js

@@ -4010,6 +4010,13 @@ var ALL_SUBSTRATE_COLUMN_SEMANTICS = ["deployment-state", "diagnostic"];
 var SubstrateColumnSemanticSchema = external_exports.enum(ALL_SUBSTRATE_COLUMN_SEMANTICS);
 var ALL_EMISSION_EXPECTATIONS = ["always", "conditional"];
 var EmissionExpectationSchema = external_exports.enum(ALL_EMISSION_EXPECTATIONS);
+var CoOccurrenceEmissionSchema = external_exports.object({
+ whenever: external_exports.string().min(1)
+});
+var EmissionExpectationDeclarationSchema = external_exports.union([
+ EmissionExpectationSchema,
+ CoOccurrenceEmissionSchema
+]);
 var SubstrateColumnStatusSchema = external_exports.enum(["active", "forward-declared", "deprecated"]);
 var SubstrateColumnSchema = external_exports.object({
  id: external_exports.string().min(1).max(128),
@@ -4021,7 +4028,7 @@ var SubstrateColumnSchema = external_exports.object({
 
  values: external_exports.array(external_exports.string().min(1)).min(1).optional(),
 
- emissionExpectation: EmissionExpectationSchema.optional(),
+ emissionExpectation: EmissionExpectationDeclarationSchema.optional(),
 
  status: SubstrateColumnStatusSchema.optional()
 });
@@ -4097,9 +4104,46 @@ new Set(
  PLATFORM_SYSTEM_ROLE_SURFACES.map((s) => s.surfaceId)
 );
 
+var RubricDispatchSchema = external_exports.object({
+
+ facet: external_exports.string().min(1).max(128),
+
+ refsFrom: external_exports.string().min(1),
+
+ refs: external_exports.record(external_exports.string().min(1), external_exports.string().min(1)).optional()
+});
+var ALL_RUBRIC_DEFAULT_REASONS = [
+ "facet-tag-absent",
+ "unmatched-value",
+ "no-bespoke-ref",
+ "pin-unresolved"
+];
+var RubricDefaultReasonSchema = external_exports.enum(ALL_RUBRIC_DEFAULT_REASONS);
+var ALL_RUBRIC_SOURCES = ["facet", "default"];
+var RubricSourceSchema = external_exports.enum(ALL_RUBRIC_SOURCES);
+var JUDGE_RUBRIC_SOURCE_COLUMN_ID = "judge.rubric_source";
+var JUDGE_RUBRIC_DEFAULT_REASON_COLUMN_ID = "judge.rubric_default_reason";
+var JUDGE_RUBRIC_FACET_COLUMN_ID = "judge.rubric_facet";
+function normalizeFacetValue(raw) {
+ return raw.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function rubricDispatchColumns(resolved) {
+ const columns = {
+ [JUDGE_RUBRIC_SOURCE_COLUMN_ID]: resolved.source
+ };
+ if (resolved.reason !== void 0) {
+ columns[JUDGE_RUBRIC_DEFAULT_REASON_COLUMN_ID] = resolved.reason;
+ }
+ if (resolved.facetValue !== null && resolved.facetValue.length > 0) {
+ columns[JUDGE_RUBRIC_FACET_COLUMN_ID] = resolved.facetValue;
+ }
+ return columns;
+}
+
 var JUDGE_RUBRIC_HASH_COLUMN_ID = "judge.rubric_hash";
 var JUDGE_CONTEXT_SCOPE_COLUMN_ID = "judge.context_scope";
 var JUDGE_MODEL_COLUMN_ID = "judge.model";
+var JUDGE_GROUNDING_CAPS_COLUMN_ID = "judge.grounding_caps";
 var JUDGE_RESERVED_COLUMN_NAMESPACE_PREFIX = "judge.";
 var JUDGE_CONTEXT_SCOPES = [
  "rubric_actual",
@@ -4114,7 +4158,9 @@ var JudgeIdentitySchema = external_exports.object({
 
  contextScope: JudgeContextScopeSchema.optional(),
 
- model: external_exports.string().min(1).optional()
+ model: external_exports.string().min(1).optional(),
+
+ groundingCaps: external_exports.string().min(1).optional()
 });
 function judgeIdentityColumns(identity) {
  const columns = {};
@@ -4122,6 +4168,8 @@ function judgeIdentityColumns(identity) {
  if (identity.contextScope !== void 0)
  columns[JUDGE_CONTEXT_SCOPE_COLUMN_ID] = identity.contextScope;
  if (identity.model !== void 0) columns[JUDGE_MODEL_COLUMN_ID] = identity.model;
+ if (identity.groundingCaps !== void 0)
+ columns[JUDGE_GROUNDING_CAPS_COLUMN_ID] = identity.groundingCaps;
  return columns;
 }
 var JudgeLensIdentityObservationSchema = external_exports.object({
@@ -4130,9 +4178,61 @@ var JudgeLensIdentityObservationSchema = external_exports.object({
 
  contextScope: external_exports.array(external_exports.string().min(1)).optional(),
 
- model: external_exports.array(external_exports.string().min(1)).optional()
+ model: external_exports.array(external_exports.string().min(1)).optional(),
+
+ groundingCaps: external_exports.array(external_exports.string().min(1)).optional()
+});
+var DimensionJudgeIdentitySchema = external_exports.object({
+
+ rubricHash: external_exports.string().min(1).optional(),
+
+ contextScope: JudgeContextScopeSchema.optional(),
+
+ model: external_exports.string().min(1).optional(),
+
+ groundingCaps: external_exports.string().min(1).optional(),
+
+ rubricSource: RubricSourceSchema.optional(),
+
+ rubricFacet: external_exports.string().min(1).optional(),
+
+ rubricDefaultReason: external_exports.string().min(1).optional()
 });
 
+var JUDGE_ASSERTION_KINDS = ["tool-not-invoked", "datum-absent"];
+var JudgeAssertionKindSchema = external_exports.enum(JUDGE_ASSERTION_KINDS);
+var JudgeAssertionSchema = external_exports.discriminatedUnion("kind", [
+ external_exports.object({
+ kind: external_exports.literal("tool-not-invoked"),
+ tool: external_exports.string().min(1)
+ }),
+ external_exports.object({
+ kind: external_exports.literal("datum-absent"),
+ datum: external_exports.string().min(1),
+ reference: external_exports.string().min(1).optional()
+ })
+]);
+var JudgeClaimReportSchema = external_exports.discriminatedUnion("status", [
+ external_exports.object({
+
+ status: external_exports.literal("emitted"),
+
+ assertions: external_exports.array(JudgeAssertionSchema)
+ }),
+ external_exports.object({
+
+ status: external_exports.literal("malformed"),
+
+ reflectionAttempted: external_exports.boolean(),
+
+ raw: external_exports.string().optional()
+ })
+]);
+var JudgeClaimContractSchema = external_exports.object({
+
+ assertionKinds: external_exports.array(JudgeAssertionKindSchema).min(1)
+}).strict();
+
 var CannedMessageRefSchema = external_exports.string().min(1).max(256);
 var ALL_GATE_FAILURE_ACTIONS = ["retry", "flag", "block"];
 var GateFailureActionSchema = external_exports.enum(ALL_GATE_FAILURE_ACTIONS);
@@ -4195,6 +4295,14 @@ var ValueDomainSchema = external_exports.discriminatedUnion("kind", [
  values: external_exports.array(external_exports.string().min(1)).min(1)
  })
 ]);
+var SCORING_CODOMAIN = {
+ "llm-judge": { min: 0, max: 10 },
+ "exact-match": { min: 0, max: 1 },
+ custom: null
+};
+function scoringCodomain(strategy) {
+ return SCORING_CODOMAIN[strategy];
+}
 var GradingDimensionSchema = external_exports.object({
 
  id: DimensionIdSchema,
@@ -4209,7 +4317,66 @@ var GradingDimensionSchema = external_exports.object({
 
  gatePolicy: GatePolicySchema.optional(),
 
- valueDomain: ValueDomainSchema.optional()
+ valueDomain: ValueDomainSchema.optional(),
+
+ rubricDispatch: RubricDispatchSchema.optional(),
+
+ judgeClaimContract: JudgeClaimContractSchema.optional()
+}).superRefine((dimension, ctx) => {
+ const codomain = scoringCodomain(dimension.scoring);
+ if (codomain === null) return;
+ const check = (value, path) => {
+ if (value === void 0) return;
+ if (value < codomain.min || value > codomain.max) {
+ ctx.addIssue({
+ code: external_exports.ZodIssueCode.custom,
+ path,
+ message: `passThreshold ${String(value)} is outside the ${dimension.scoring} codomain [${String(codomain.min)}, ${String(codomain.max)}]. ` + (dimension.scoring === "llm-judge" ? `The llm-judge scorer emits a 0\u201310 score; a threshold on another scale never gates as intended. ` : `exact-match emits 1 (pass) or 0 (fail). `) + `Declare passThreshold within [${String(codomain.min)}, ${String(codomain.max)}].`
+ });
+ }
+ };
+ check(dimension.passThreshold, ["passThreshold"]);
+ check(dimension.gatePolicy?.passThreshold, ["gatePolicy", "passThreshold"]);
+ if (dimension.judgeClaimContract !== void 0 && dimension.scoring !== "llm-judge") {
+ ctx.addIssue({
+ code: external_exports.ZodIssueCode.custom,
+ path: ["judgeClaimContract"],
+ message: `judgeClaimContract is only valid on an 'llm-judge' dimension (this dimension is '${dimension.scoring}'); only the llm-judge scorer emits a structured judge claim.`
+ });
+ }
+ if (dimension.rubricDispatch !== void 0) {
+ if (dimension.scoring !== "llm-judge") {
+ ctx.addIssue({
+ code: external_exports.ZodIssueCode.custom,
+ path: ["rubricDispatch"],
+ message: `rubricDispatch is only valid on an 'llm-judge' dimension (this dimension is '${dimension.scoring}'); only the llm-judge scorer resolves a rubric.`
+ });
+ }
+ if (dimension.rubricRef === void 0 || dimension.rubricRef === "") {
+ ctx.addIssue({
+ code: external_exports.ZodIssueCode.custom,
+ path: ["rubricDispatch"],
+ message: `a dimension with rubricDispatch must also declare 'rubricRef' \u2014 it is the REQUIRED default rubric an unknown/unmatched facet falls back to.`
+ });
+ }
+ const refs = dimension.rubricDispatch.refs;
+ if (refs !== void 0) {
+ const byNormalized = new Map();
+ for (const key of Object.keys(refs)) {
+ const norm = normalizeFacetValue(key);
+ const prior = byNormalized.get(norm);
+ if (prior !== void 0) {
+ ctx.addIssue({
+ code: external_exports.ZodIssueCode.custom,
+ path: ["rubricDispatch", "refs", key],
+ message: `rubricDispatch.refs keys '${prior}' and '${key}' normalize to the same facet value '${norm}' \u2014 an ambiguous pin. Give them distinct normalized values.`
+ });
+ } else {
+ byNormalized.set(norm, key);
+ }
+ }
+ }
+ }
 });
 var SurfaceStatusSchema = external_exports.enum(["active", "forward-declared", "deprecated"]);
 var RemovalSupersededBySchema = external_exports.object({
@@ -4238,6 +4405,41 @@ var RemovedCohortTagSchema = RemovalProvenanceSchema.extend({
 
  tag: CohortTagSchema
 });
+var TrajectoryPolicySchema = external_exports.object({
+
+ conversationIdColumn: external_exports.string().min(1).optional(),
+
+ refusalPatterns: external_exports.array(external_exports.string().min(1)).optional(),
+
+ reaskPatterns: external_exports.array(external_exports.string().min(1)).optional(),
+
+ availableTools: external_exports.array(external_exports.string().min(1)).optional(),
+
+ nullKeyValues: external_exports.array(external_exports.string().min(1)).optional(),
+
+ coarseKeyPatterns: external_exports.array(external_exports.string().min(1)).optional()
+});
+var ALL_POST_OUTCOME_STAGE_KINDS = [
+ "deferred-delivery",
+ "filter",
+ "cache",
+ "rate-limit",
+ "fan-in",
+ "other"
+];
+var PostOutcomeStageKindSchema = external_exports.enum(ALL_POST_OUTCOME_STAGE_KINDS);
+var ALL_POST_OUTCOME_OBSERVABILITIES = ["declared", "reconciled"];
+var PostOutcomeObservabilitySchema = external_exports.enum(ALL_POST_OUTCOME_OBSERVABILITIES);
+var PostOutcomeStageSchema = external_exports.object({
+
+ kind: PostOutcomeStageKindSchema,
+
+ observability: PostOutcomeObservabilitySchema.default("declared"),
+
+ description: external_exports.string().optional(),
+
+ settleMs: external_exports.number().int().positive().optional()
+});
 var SurfaceDeclarationSchema = external_exports.object({
 
  id: SurfaceIdSchema,
@@ -4256,7 +4458,11 @@ var SurfaceDeclarationSchema = external_exports.object({
 
  removedDimensions: external_exports.array(RemovedDimensionSchema).default([]),
 
- removedCohortTags: external_exports.array(RemovedCohortTagSchema).default([])
+ removedCohortTags: external_exports.array(RemovedCohortTagSchema).default([]),
+
+ trajectoryPolicy: TrajectoryPolicySchema.optional(),
+
+ postOutcomeStages: external_exports.array(external_exports.string().min(1)).optional()
 });
 var PricingEntrySchema = external_exports.object({
 
@@ -4292,6 +4498,8 @@ external_exports.object({
 
  surfaces: external_exports.array(SurfaceDeclarationSchema),
 
+ postOutcomeStages: external_exports.record(external_exports.string().min(1), PostOutcomeStageSchema).optional(),
+
  routings: external_exports.array(SurfaceRoutingSchema).optional(),
 
  pricing: external_exports.record(external_exports.string(), PricingEntrySchema).optional(),
@@ -4782,7 +4990,8 @@ var LightSnapshotSchema = external_exports.object({
  rawRequestOmitted: external_exports.boolean().optional(),
 
  rawResponsePresence: external_exports.enum(["present", "omitted-by-policy", "pending-attach", "failed-attach"]).optional()
-});
+
+}).passthrough();
 var DimensionResultSchema = external_exports.object({
  dimensionId: DimensionIdSchema,
  passed: external_exports.boolean(),
@@ -4793,8 +5002,13 @@ var DimensionResultSchema = external_exports.object({
 
  score: external_exports.number().optional(),
 
- rationale: external_exports.string().optional()
-});
+ rationale: external_exports.string().optional(),
+
+ judge: DimensionJudgeIdentitySchema.optional(),
+
+ claim: JudgeClaimReportSchema.optional()
+
+}).passthrough();
 var ALL_GATE_ACTIONS_TAKEN = [
  "pass",
  "retry-then-pass",
@@ -4804,6 +5018,21 @@ var ALL_GATE_ACTIONS_TAKEN = [
  "block"
 ];
 var GateActionTakenSchema = external_exports.enum(ALL_GATE_ACTIONS_TAKEN);
+var DispatchDecisionSchema = external_exports.object({
+
+ dimensionId: DimensionIdSchema,
+
+ scoringStrategy: external_exports.string(),
+
+ dispatchOccurred: external_exports.boolean(),
+
+ rubricResolution: external_exports.object({
+ attempted: external_exports.boolean(),
+ succeeded: external_exports.boolean(),
+ rubricHash: external_exports.string().optional(),
+ failureSubtype: external_exports.enum(["unloadable-rubric", "never-dispatched", "missing-ref"]).optional()
+ }).optional()
+});
 var GateOutcomeSchema = external_exports.object({
 
  action: GateActionTakenSchema,
@@ -4821,7 +5050,9 @@ var GateOutcomeSchema = external_exports.object({
  })
  ).default([]),
 
- actionDetails: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+ actionDetails: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+
+ dispatchDecisions: external_exports.array(DispatchDecisionSchema).optional()
 });
 var SurfaceSnapshotSchema = external_exports.object({
  surfaceId: SurfaceIdSchema,
@@ -4842,7 +5073,8 @@ var SurfaceSnapshotSchema = external_exports.object({
  ).default([]),
 
  gateOutcome: GateOutcomeSchema.optional()
-});
+
+}).passthrough();
 var EvaluationEventKindSchema = external_exports.enum([
  "evaluation",
  "availability.transition",
@@ -5625,6 +5857,7 @@ var GROUNDING_COVERAGE_DISPOSITIONS = [
  "present-in-scope",
  "truncated-out",
  "not-found",
+ "grounding-sufficient",
  "no-marker-to-check",
  "not-applicable"
 ];
@@ -5674,6 +5907,8 @@ external_exports.object({
 
  flagged: external_exports.array(FlaggedVerdictSchema),
 
+ trustDrivers: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative()),
+
  corpusRates: ReliabilityCorpusRatesSchema
 });
 var ESCALATION_REASONS = ["both-checks-not-applicable"];
@@ -5715,6 +5950,740 @@ external_exports.object({
  agreementRate: external_exports.number().min(0).max(1).nullable()
 });
 
+var TrajectoryPredicateSchema = external_exports.enum([
+ "p3-disclaim-then-recover",
+ "p2-user-reask",
+ "p1-and-t4"
+]);
+var TrajectoryEvidenceRoleSchema = external_exports.enum([
+ "refusal",
+ "recovery",
+ "user-reask",
+ "availability-unused"
+]);
+var TrajectoryFindingEvidenceSchema = external_exports.object({
+
+ turnIndex: external_exports.number().int().nonnegative(),
+
+ eventId: external_exports.string().min(1),
+
+ occurredAt: external_exports.string().min(1),
+
+ role: TrajectoryEvidenceRoleSchema,
+
+ note: external_exports.string().max(512).optional()
+});
+var TrajectoryFindingSchema = external_exports.object({
+
+ predicate: TrajectoryPredicateSchema,
+
+ conversationId: external_exports.string().min(1),
+
+ surfaceId: SurfaceIdSchema,
+
+ offendingTurnIndices: external_exports.array(external_exports.number().int().nonnegative()).min(1),
+
+ evidence: external_exports.array(TrajectoryFindingEvidenceSchema).min(1),
+
+ detectedAt: external_exports.string().min(1).optional()
+});
+external_exports.object({
+
+ trajectoryCount: external_exports.number().int().nonnegative(),
+
+ nullKeyEventCount: external_exports.number().int().nonnegative(),
+
+ coarseKeyEventCount: external_exports.number().int().nonnegative(),
+
+ evaluatedTurnCount: external_exports.number().int().nonnegative(),
+
+ noOutputTextTurnCount: external_exports.number().int().nonnegative(),
+
+ predicatesEvaluated: external_exports.array(TrajectoryPredicateSchema),
+
+ findings: external_exports.array(TrajectoryFindingSchema)
+});
+
+var LessonsDraftingSurfaceKeySchema = external_exports.enum([
+ "skillDrafting",
+ "lessonDrafting",
+ "fixtureGeneration"
+]);
+LessonsDraftingSurfaceKeySchema.options;
+var LessonsCapabilityStatusSchema = external_exports.enum(["available", "unavailable", "degraded"]);
+var LessonsCapabilityReasonSchema = external_exports.enum(["opted-out", "enablement-changed"]);
+external_exports.object({
+ status: LessonsCapabilityStatusSchema,
+
+ reason: LessonsCapabilityReasonSchema.optional(),
+
+ missingKeys: external_exports.array(LessonsDraftingSurfaceKeySchema).optional()
+});
+
+var ALL_FINDING_SOURCES = [
+ "verdict-reliability",
+ "judge-liveness",
+ "judge-malfunction",
+ "trajectory",
+ "orthogonality-hypothesis",
+ "coverage-gap",
+ "quarantine-candidate",
+ "retirement-candidate",
+ "dark-mass-blindspot",
+ "emission-gap",
+ "reach-gap"
+];
+var FindingSourceSchema = external_exports.enum(ALL_FINDING_SOURCES);
+var ALL_FINDING_GRAINS = ["run", "conversation", "structural"];
+var FindingGrainSchema = external_exports.enum(ALL_FINDING_GRAINS);
+var FindingRefSchema = external_exports.object({
+ primary: external_exports.object({
+ grain: FindingGrainSchema,
+
+ id: external_exports.string().min(1)
+ }),
+ attributes: external_exports.object({
+ source: FindingSourceSchema,
+ surfaceId: SurfaceIdSchema,
+ dimensionId: DimensionIdSchema.optional(),
+
+ driver: external_exports.string().min(1).optional(),
+
+ predicate: external_exports.string().min(1).optional(),
+
+ axis: external_exports.string().min(1).optional(),
+
+ clusterId: external_exports.string().min(1).optional()
+ })
+});
+var ALL_TRIAGE_DISPOSITIONS = ["confirmed-defect", "false-alarm", "acknowledged"];
+var TriageDispositionSchema = external_exports.enum(ALL_TRIAGE_DISPOSITIONS);
+var TriageRecordSchema = external_exports.object({
+
+ findingRef: FindingRefSchema,
+ disposition: TriageDispositionSchema,
+
+ rationale: external_exports.string().min(1),
+
+ approverId: external_exports.string().min(1),
+
+ occurredAt: external_exports.string().datetime(),
+
+ evidenceSnapshotRef: external_exports.string().min(1).optional(),
+
+ asOf: external_exports.string().datetime().optional(),
+
+ proposalRef: external_exports.string().min(1).optional()
+});
+var ALL_TRIAGE_STATES = [
+ "untriaged",
+ "confirmed-defect",
+ "false-alarm",
+ "acknowledged",
+ "resolved"
+];
+var TriageStateSchema = external_exports.enum(ALL_TRIAGE_STATES);
+var ALL_PROPOSAL_KINDS = [
+ "grounding-cap-bump",
+ "adjust-threshold",
+ "fix-rubric-ref",
+ "gate-dimension",
+ "predicate-downweight",
+ "retire-surface",
+ "release-from-quarantine",
+ "declare-axis",
+ "author-fixture"
+];
+var ProposalKindSchema = external_exports.enum(ALL_PROPOSAL_KINDS);
+var ALL_PROPOSAL_STATUSES = ["pending", "approved", "rejected"];
+var ProposalStatusSchema = external_exports.enum(ALL_PROPOSAL_STATUSES);
+var ALL_PROPOSAL_AVAILABILITIES = ["minted", "none-for-source", "not-applicable"];
+external_exports.enum(ALL_PROPOSAL_AVAILABILITIES);
+external_exports.object({
+ proposalRef: external_exports.string().min(1),
+ kind: ProposalKindSchema,
+
+ findingRef: FindingRefSchema,
+
+ summary: external_exports.string().min(1),
+
+ approverId: external_exports.string().min(1),
+ occurredAt: external_exports.string().datetime(),
+ status: ProposalStatusSchema.default("pending")
+});
+var ALL_ATTENTION_SEVERITIES = ["alarm", "needs-review", "coverage"];
+var AttentionSeveritySchema = external_exports.enum(ALL_ATTENTION_SEVERITIES);
+var VerdictReliabilityEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("verdict-reliability"),
+
+ driver: external_exports.string().min(1),
+
+ sampleCorrelationIds: external_exports.array(external_exports.string().min(1)),
+
+ sampleEventIds: external_exports.array(external_exports.string().min(1))
+});
+var JudgeMalfunctionEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("judge-malfunction"),
+
+ sampleCorrelationIds: external_exports.array(external_exports.string().min(1)),
+
+ sampleEventIds: external_exports.array(external_exports.string().min(1)),
+
+ reflectionAttempted: external_exports.boolean()
+});
+var OrthogonalityEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("orthogonality-hypothesis"),
+
+ axis: external_exports.string().min(1),
+
+ etaSquared: external_exports.number()
+});
+var TrajectoryEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("trajectory"),
+
+ predicate: TrajectoryPredicateSchema,
+
+ conversationId: external_exports.string().min(1)
+});
+var JudgeDispatchReasonSchema = external_exports.enum([
+ "never-dispatched",
+ "unloadable-rubric",
+ "missing-ref",
+ "unspecified"
+]);
+var JudgeLivenessEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("judge-liveness"),
+
+ variant: external_exports.enum(["not-dispatching", "not-lens-dispatched"]),
+
+ dimensionId: DimensionIdSchema.optional(),
+
+ observedCount: external_exports.number().int().nonnegative().optional(),
+
+ dominantReason: JudgeDispatchReasonSchema.optional(),
+
+ surfaceId: SurfaceIdSchema.optional(),
+
+ inlineCount: external_exports.number().int().nonnegative().optional()
+});
+var CoverageGapEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("coverage-gap"),
+
+ altitude: external_exports.enum(["surface", "dimension"]),
+
+ surfaceStatus: external_exports.enum(["active", "deprecated"])
+});
+var RetirementCandidateEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("retirement-candidate"),
+
+ surfaceStatus: external_exports.enum(["active", "deprecated"])
+});
+var QuarantineCandidateEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("quarantine-candidate"),
+
+ candidateStream: external_exports.literal("parse-anomaly-frequent")
+});
+var EmissionGapEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("emission-gap"),
+
+ variant: external_exports.enum(["deployment-broken", "co-occurrence-gap", "no-events"]),
+
+ columnId: external_exports.string().min(1),
+
+ whenever: external_exports.string().min(1).optional()
+});
+var ReachGapEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("reach-gap"),
+
+ variant: external_exports.enum(["horizon", "shortfall"]),
+
+ surfaceId: SurfaceIdSchema,
+
+ unobservedStageCount: external_exports.number().int().nonnegative().optional(),
+
+ hasSuppressingStage: external_exports.boolean().optional(),
+
+ darkRate: external_exports.number().optional(),
+
+ darkCount: external_exports.number().int().nonnegative().optional()
+});
+var AttentionEvidenceSchema = external_exports.discriminatedUnion("kind", [
+ VerdictReliabilityEvidenceSchema,
+ JudgeMalfunctionEvidenceSchema,
+ OrthogonalityEvidenceSchema,
+ TrajectoryEvidenceSchema,
+ JudgeLivenessEvidenceSchema,
+ CoverageGapEvidenceSchema,
+ RetirementCandidateEvidenceSchema,
+ QuarantineCandidateEvidenceSchema,
+ EmissionGapEvidenceSchema,
+ ReachGapEvidenceSchema
+]);
+var AttentionFindingSchema = external_exports.object({
+ findingRef: FindingRefSchema,
+
+ findingKey: external_exports.string().min(1),
+ source: FindingSourceSchema,
+ severity: AttentionSeveritySchema,
+
+ count: external_exports.number().int().positive(),
+
+ firstSeen: external_exports.string().min(1),
+
+ lastSeen: external_exports.string().min(1),
+ evidence: AttentionEvidenceSchema
+});
+AttentionFindingSchema.extend({
+
+ triageState: TriageStateSchema,
+
+ latestTriage: TriageRecordSchema.optional()
+});
+var ExemplarJudgeDecisionSchema = external_exports.object({
+ passed: external_exports.boolean(),
+
+ expected: external_exports.string().optional(),
+
+ actual: external_exports.string().optional(),
+
+ rationale: external_exports.string().optional()
+});
+var VerdictReliabilityExemplarSchema = external_exports.object({
+ source: external_exports.literal("verdict-reliability"),
+ eventId: external_exports.string().min(1),
+ correlationId: external_exports.string().min(1).optional(),
+ occurredAt: external_exports.string().min(1),
+ dimensionId: DimensionIdSchema,
+
+ driver: external_exports.string().min(1),
+ judge: ExemplarJudgeDecisionSchema,
+
+ prompt: external_exports.string().optional(),
+
+ response: external_exports.string().optional(),
+
+ traceClaims: external_exports.array(TraceClaimCheckSchema),
+
+ groundingClaims: external_exports.array(GroundingClaimCheckSchema)
+});
+var JudgeMalfunctionExemplarSchema = external_exports.object({
+ source: external_exports.literal("judge-malfunction"),
+ eventId: external_exports.string().min(1),
+ correlationId: external_exports.string().min(1).optional(),
+ occurredAt: external_exports.string().min(1),
+ dimensionId: DimensionIdSchema,
+
+ reflectionAttempted: external_exports.boolean(),
+
+ raw: external_exports.string().optional(),
+
+ prompt: external_exports.string().optional()
+});
+var OrthogonalityGroupSchema = external_exports.object({
+
+ value: external_exports.string().min(1),
+
+ meanScore: external_exports.number(),
+
+ count: external_exports.number().int().nonnegative()
+});
+var InstrumentPartitionCellSchema = external_exports.object({
+
+ identity: external_exports.string().min(1),
+
+ n: external_exports.number().int().nonnegative(),
+
+ meanScore: external_exports.number()
+});
+var OrthogonalityExemplarSchema = external_exports.object({
+ source: external_exports.literal("orthogonality-hypothesis"),
+ dimensionId: DimensionIdSchema,
+
+ axis: external_exports.string().min(1),
+
+ etaSquared: external_exports.number(),
+
+ etaSquaredExpectedUnderNull: external_exports.number().nullable(),
+
+ omegaSquared: external_exports.number(),
+
+ adjustedPValue: external_exports.number().nullable(),
+
+ pValue: external_exports.number().nullable(),
+
+ scoredEventCount: external_exports.number().int().nonnegative(),
+
+ analyzedGroupCount: external_exports.number().int().nonnegative(),
+
+ groupsTruncated: external_exports.boolean(),
+
+ groupTimeOverlap: external_exports.number(),
+
+ instrumentHeterogeneous: external_exports.boolean(),
+
+ instrumentPartition: external_exports.array(InstrumentPartitionCellSchema),
+
+ identifierLike: external_exports.boolean(),
+
+ effectSizeUncertain: external_exports.boolean(),
+
+ scoreMax: external_exports.number().positive().nullable(),
+
+ groups: external_exports.array(OrthogonalityGroupSchema)
+});
+var TrajectoryTurnDetailSchema = external_exports.object({
+
+ turnIndex: external_exports.number().int().nonnegative(),
+
+ eventId: external_exports.string().min(1),
+ occurredAt: external_exports.string().min(1),
+ role: TrajectoryEvidenceRoleSchema,
+
+ note: external_exports.string().optional(),
+
+ text: external_exports.string().nullable()
+});
+var TrajectoryExemplarSchema = external_exports.object({
+ source: external_exports.literal("trajectory"),
+ conversationId: external_exports.string().min(1),
+ surfaceId: SurfaceIdSchema,
+
+ predicate: TrajectoryPredicateSchema,
+
+ predicatesFired: external_exports.array(TrajectoryPredicateSchema),
+
+ turns: external_exports.array(TrajectoryTurnDetailSchema)
+});
+var JudgeDispatchFailureBreakdownSchema = external_exports.object({
+ unloadableRubric: external_exports.number().int().nonnegative(),
+ missingRef: external_exports.number().int().nonnegative(),
+ neverDispatched: external_exports.number().int().nonnegative(),
+ unspecified: external_exports.number().int().nonnegative()
+});
+var JudgeLivenessExemplarSchema = external_exports.object({
+ source: external_exports.literal("judge-liveness"),
+
+ variant: external_exports.enum(["not-dispatching", "not-lens-dispatched"]),
+
+ dimensionId: DimensionIdSchema.optional(),
+
+ observedCount: external_exports.number().int().nonnegative().optional(),
+
+ dispatchedCount: external_exports.number().int().nonnegative().optional(),
+
+ failureSubtypes: JudgeDispatchFailureBreakdownSchema.optional(),
+
+ dominantReason: JudgeDispatchReasonSchema.optional(),
+
+ failureAction: external_exports.enum(["retry", "flag", "block"]).nullable().optional(),
+
+ rubricRef: external_exports.string().optional(),
+
+ surfaceId: SurfaceIdSchema.optional(),
+
+ inlineDimensionIds: external_exports.array(DimensionIdSchema).optional()
+});
+var CoverageGapExemplarSchema = external_exports.object({
+ source: external_exports.literal("coverage-gap"),
+
+ altitude: external_exports.enum(["surface", "dimension"]),
+ surfaceId: SurfaceIdSchema,
+
+ dimensionId: DimensionIdSchema.optional(),
+ surfaceStatus: external_exports.enum(["active", "deprecated"]),
+
+ observedEventCount: external_exports.number().int().nonnegative(),
+
+ surfaceEventCount: external_exports.number().int().nonnegative(),
+
+ declaredDimensionCount: external_exports.number().int().nonnegative(),
+
+ observedFrom: external_exports.string().min(1),
+
+ observedTo: external_exports.string().min(1)
+});
+var RetirementCandidateExemplarSchema = external_exports.object({
+ source: external_exports.literal("retirement-candidate"),
+ surfaceId: SurfaceIdSchema,
+ surfaceStatus: external_exports.enum(["active", "deprecated"]),
+
+ structuralConsumerCount: external_exports.number().int().nonnegative(),
+
+ declaredDimensionCount: external_exports.number().int().nonnegative(),
+
+ lastCapturedAt: external_exports.string().min(1)
+});
+var QuarantineParseAnomalySchema = external_exports.object({
+
+ field: external_exports.string().min(1),
+
+ recoveredAs: external_exports.string().min(1),
+
+ recoveryStrategy: external_exports.string().min(1),
+
+ rawValue: external_exports.string().nullable()
+});
+var QuarantineCandidateExemplarSchema = external_exports.object({
+ source: external_exports.literal("quarantine-candidate"),
+ surfaceId: SurfaceIdSchema,
+
+ candidateStream: external_exports.literal("parse-anomaly-frequent"),
+
+ count: external_exports.number().int().nonnegative(),
+
+ lifecycleState: QuarantineLifecycleStateSchema,
+
+ firstSeen: external_exports.string().min(1),
+
+ lastSeen: external_exports.string().min(1),
+
+ anomalies: external_exports.array(QuarantineParseAnomalySchema)
+});
+var EmissionGapExemplarSchema = external_exports.object({
+ source: external_exports.literal("emission-gap"),
+ variant: external_exports.enum(["deployment-broken", "co-occurrence-gap", "no-events"]),
+ surfaceId: SurfaceIdSchema,
+ columnId: external_exports.string().min(1),
+
+ control: ControlAttributeSchema,
+
+ visibility: VisibilityAttributeSchema,
+
+ description: external_exports.string().optional(),
+
+ observedEventCount: external_exports.number().int().nonnegative(),
+
+ emittedCount: external_exports.number().int().nonnegative(),
+
+ whenever: external_exports.string().min(1).optional(),
+
+ conditionMatchedCount: external_exports.number().int().nonnegative().optional(),
+
+ observedFrom: external_exports.string().min(1),
+
+ observedTo: external_exports.string().min(1),
+
+ renameCandidate: external_exports.string().min(1).optional()
+});
+var ReachGapStageSchema = external_exports.object({
+
+ id: external_exports.string().min(1),
+
+ kind: PostOutcomeStageKindSchema,
+
+ observability: PostOutcomeObservabilitySchema,
+
+ description: external_exports.string().optional()
+});
+var ReachShortfallSchema = external_exports.object({
+ delivered: external_exports.number().int().nonnegative(),
+ dark: external_exports.number().int().nonnegative(),
+ inFlight: external_exports.number().int().nonnegative(),
+
+ settled: external_exports.number().int().nonnegative(),
+
+ darkRate: external_exports.number().nullable(),
+
+ medianDarkAgeMs: external_exports.number().nullable(),
+
+ byLastStage: external_exports.array(
+ external_exports.object({ stageId: external_exports.string().nullable(), dark: external_exports.number().int().nonnegative() })
+ )
+});
+var ReachGapExemplarSchema = external_exports.object({
+ source: external_exports.literal("reach-gap"),
+
+ variant: external_exports.enum(["horizon", "shortfall"]),
+ surfaceId: SurfaceIdSchema,
+
+ scoredOutcomeCount: external_exports.number().int().nonnegative(),
+
+ stages: external_exports.array(ReachGapStageSchema),
+
+ unobservedStageCount: external_exports.number().int().nonnegative().optional(),
+
+ hasSuppressingStage: external_exports.boolean().optional(),
+
+ shortfall: ReachShortfallSchema.optional(),
+
+ observedFrom: external_exports.string().min(1),
+
+ observedTo: external_exports.string().min(1)
+});
+var AttentionExemplarSchema = external_exports.discriminatedUnion("source", [
+ VerdictReliabilityExemplarSchema,
+ JudgeMalfunctionExemplarSchema,
+ OrthogonalityExemplarSchema,
+ TrajectoryExemplarSchema,
+ JudgeLivenessExemplarSchema,
+ CoverageGapExemplarSchema,
+ RetirementCandidateExemplarSchema,
+ QuarantineCandidateExemplarSchema,
+ EmissionGapExemplarSchema,
+ ReachGapExemplarSchema
+]);
+var AttentionSampleRefSchema = external_exports.object({
+ eventId: external_exports.string().min(1),
+ correlationId: external_exports.string().min(1).optional(),
+ occurredAt: external_exports.string().min(1)
+});
+external_exports.object({
+ findingKey: external_exports.string().min(1),
+ exemplar: AttentionExemplarSchema.nullable(),
+ sampleCount: external_exports.number().int().nonnegative(),
+ samples: external_exports.array(AttentionSampleRefSchema),
+
+ reAdjudicable: external_exports.boolean().optional()
+});
+
+var ReachFootprintSchema = external_exports.object({
+
+ correlationId: external_exports.string().min(1),
+
+ surfaceId: SurfaceIdSchema,
+
+ stageId: external_exports.string().min(1),
+
+ occurredAt: external_exports.string().datetime()
+});
+external_exports.union([
+ ReachFootprintSchema,
+ external_exports.object({ footprints: external_exports.array(ReachFootprintSchema).min(1) })
+]);
+var ALL_REACH_DISPOSITIONS = [
+ "in-flight",
+ "delivered",
+ "dark",
+ "superseded",
+ "expired"
+];
+external_exports.enum(ALL_REACH_DISPOSITIONS);
+
+var FacetCoverageEntrySchema = external_exports.object({
+ facet: external_exports.string().min(1),
+ scoredCount: external_exports.number().int().nonnegative(),
+ source: external_exports.enum(["facet", "default"]),
+ defaultReason: RubricDefaultReasonSchema.optional()
+});
+var FacetDefaultBreakdownSchema = external_exports.object({
+
+ total: external_exports.number().int().nonnegative(),
+
+ noBespokeRef: external_exports.number().int().nonnegative(),
+
+ unmatchedValue: external_exports.number().int().nonnegative(),
+
+ pinUnresolved: external_exports.number().int().nonnegative()
+});
+var FacetCoverageReportSchema = external_exports.object({
+ surfaceId: SurfaceIdSchema,
+
+ dimensionId: DimensionIdSchema.optional(),
+
+ facet: external_exports.string().min(1).optional(),
+
+ scoredCount: external_exports.number().int().nonnegative(),
+
+ scoredOnDefault: external_exports.number().int().nonnegative(),
+
+ untaggedCount: external_exports.number().int().nonnegative(),
+
+ facetsSeen: external_exports.number().int().nonnegative(),
+
+ bespokeCount: external_exports.number().int().nonnegative(),
+
+ defaultOnly: FacetDefaultBreakdownSchema,
+
+ facets: external_exports.array(FacetCoverageEntrySchema)
+});
+external_exports.object({
+ reports: external_exports.array(FacetCoverageReportSchema)
+});
+
+var MULTIPLEX_RUN_MAX_VENDORS = 8;
+var MultiplexRunTokensSchema = external_exports.object({
+ input: external_exports.number().nonnegative(),
+ output: external_exports.number().nonnegative(),
+ cacheRead: external_exports.number().nonnegative().optional(),
+ cacheWrite: external_exports.number().nonnegative().optional()
+});
+external_exports.object({
+
+ sourceEventId: external_exports.string().min(1).optional(),
+
+ sourceCorrelationId: external_exports.string().min(1).optional(),
+
+ targetSurfaceId: external_exports.string().min(1).optional(),
+
+ vendorIds: external_exports.array(external_exports.string().min(1)).min(2).max(MULTIPLEX_RUN_MAX_VENDORS),
+
+ label: external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/, "label must match [A-Za-z0-9._-]"),
+
+ approverId: external_exports.string().min(1),
+
+ acknowledgedEstimateUsd: external_exports.number().nonnegative().optional()
+}).refine((b) => b.sourceEventId === void 0 !== (b.sourceCorrelationId === void 0), {
+ message: "provide exactly one of sourceEventId or sourceCorrelationId"
+});
+var MultiplexRunVendorEstimateSchema = external_exports.object({
+ vendorId: external_exports.string(),
+ estimatedUsd: external_exports.number().nonnegative().nullable(),
+ priced: external_exports.boolean()
+});
+var MultiplexRunEstimateSchema = external_exports.object({
+ totalUsd: external_exports.number().nonnegative(),
+ thresholdUsd: external_exports.number().nonnegative(),
+ perVendor: external_exports.array(MultiplexRunVendorEstimateSchema),
+ basis: external_exports.literal("source-tokens"),
+ sourceTokens: MultiplexRunTokensSchema,
+
+ unpricedVendorIds: external_exports.array(external_exports.string())
+});
+var MultiplexRunDimensionSchema = external_exports.object({
+ dimensionId: external_exports.string(),
+ passed: external_exports.boolean(),
+
+ score: external_exports.number().nullable()
+});
+var MultiplexRunLegSchema = external_exports.object({
+ vendorId: external_exports.string(),
+ role: external_exports.enum(["primary", "observer"]),
+ callId: external_exports.string(),
+ correlationId: external_exports.string(),
+ occurredAt: external_exports.string(),
+
+ servedModel: external_exports.string().nullable(),
+
+ response: external_exports.string().nullable(),
+ tokens: MultiplexRunTokensSchema,
+ latencyMs: external_exports.number().nullable(),
+ costUsd: external_exports.number().nullable(),
+
+ dimensions: external_exports.array(MultiplexRunDimensionSchema),
+
+ gateAction: external_exports.string().optional()
+});
+var MultiplexRunFailureSchema = external_exports.object({
+ vendorId: external_exports.string(),
+ error: external_exports.string()
+});
+external_exports.discriminatedUnion("status", [
+ external_exports.object({
+ status: external_exports.literal("confirmation-required"),
+ estimate: MultiplexRunEstimateSchema
+ }),
+ external_exports.object({
+ status: external_exports.literal("ran"),
+ correlationId: external_exports.string(),
+ surfaceId: external_exports.string(),
+ label: external_exports.string(),
+ estimate: MultiplexRunEstimateSchema,
+ legs: external_exports.array(MultiplexRunLegSchema),
+ failed: external_exports.array(MultiplexRunFailureSchema).optional(),
+ scoredDuringRun: external_exports.boolean()
+ })
+]);
+
 var HolonographGradeAfterReportError = class extends Error {
  constructor() {
  super(
@@ -6771,10 +7740,13 @@ var HolonographClient = class {
  return this.declaredColumns;
  }
 
- apparatusStampedColumns(light, judgeIdentity) {
+ apparatusStampedColumns(light, judgeIdentity, rubricDispatch) {
  const columns = { ...this.substrate.columns };
  if (light.servedModel !== void 0) columns[SERVED_MODEL_COLUMN_ID] = light.servedModel;
  if (judgeIdentity !== void 0) Object.assign(columns, judgeIdentityColumns(judgeIdentity));
+ if (rubricDispatch !== void 0) {
+ Object.assign(columns, rubricDispatchColumns(rubricDispatch));
+ }
  return columns;
  }
 
@@ -6933,6 +7905,8 @@ var HolonographClient = class {
  };
  if (d.score !== void 0) dim.score = d.score;
  if (d.rationale !== void 0) dim.rationale = d.rationale;
+ if (d.judge !== void 0) dim.judge = d.judge;
+ if (d.claim !== void 0) dim.claim = d.claim;
  return dim;
  }),
  cohortTags: primaryCohortTags,
@@ -6957,7 +7931,11 @@ var HolonographClient = class {
  substrate: {
  ...this.substrate,
  lightSourceIdentifier: callResult.record.lightSourceId,
- columns: this.apparatusStampedColumns(callResult.record.light, outcome.judgeIdentity)
+ columns: this.apparatusStampedColumns(
+ callResult.record.light,
+ outcome.judgeIdentity,
+ outcome.rubricDispatch
+ )
  },
  surface
  });
@@ -7003,6 +7981,8 @@ var HolonographClient = class {
  };
  if (d.score !== void 0) dim.score = d.score;
  if (d.rationale !== void 0) dim.rationale = d.rationale;
+ if (d.judge !== void 0) dim.judge = d.judge;
+ if (d.claim !== void 0) dim.claim = d.claim;
  return dim;
  }),
  cohortTags: observerCohortTags,