@o11y-one/api-agentic 0.0.0

package/dist/o11y_one/agentic/v1/trace_view_pb.d.ts

@@ -0,0 +1,4292 @@
+import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2";
+import type { Timestamp } from "@bufbuild/protobuf/wkt";
+import type { AgenticEvaluationCapabilitiesV1, AgentTraceListFilterV1, CompletenessStateV1, CostAmountV1, EvaluationFreshnessV1, EvaluationOperationDimensionV1, EvaluationRateDimensionNoteV1, EvaluationTokenAccountingV1, MetricAvailabilityV1, PrincipalRefV1, ProviderUsageRecordV1, RecoveryActionV1 } from "./evaluation_pb.js";
+import type { AgentRunGroupingConfidenceV1, AgentRunGroupingV1, ConfirmAgentRunGroupingRequestSchema, ConfirmAgentRunGroupingResponseSchema, ConversationCompletenessStateV1, ConversationCompletenessV1, GroupingRedirectV1 } from "./agent_run_pb.js";
+import type { ArtifactLinkConflictPostureV1, ArtifactLinkFallbackReasonV1, ArtifactLinkSourceKindV1, ArtifactLinkStatusV1, ArtifactLinkV1, ArtifactRelationV1, ArtifactResolverPostureV1, ArtifactRoleV1, ArtifactTypeV1, EvidenceAnchorV1, LinkExternalArtifactRequestSchema, LinkExternalArtifactResponseSchema } from "./artifact_pb.js";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file o11y_one/agentic/v1/trace_view.proto.
+ */
+export declare const file_o11y_one_agentic_v1_trace_view: GenFile;
+/**
+ * The population this surface reads, declared rather than described.
+ *
+ * `DECISION:960` gave the Operations tab a frozen list of dimensions it refuses
+ * to break down by, and `EVALUATION_OPERATION_DIMENSION_V1_TELEMETRY_SPAN` is
+ * the seventh. That is not a row predicate — the Operations tab does not filter
+ * telemetry spans out of a costing query, it declines to offer a telemetry-span
+ * breakdown at all. This surface answers exactly that refused dimension, and it
+ * carries the SAME enum value rather than a second spelling of the word, so
+ * that the two surfaces cannot drift into disagreeing about their shared edge.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceSpanPopulationBoundaryV1
+ */
+export type TraceSpanPopulationBoundaryV1 = Message<"o11y_one.agentic.v1.TraceSpanPopulationBoundaryV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.EvaluationOperationDimensionV1 dimension = 1;
+     */
+    dimension: EvaluationOperationDimensionV1;
+    /**
+     * `trace_scoped_telemetry_spans_only`. A constant rather than a literal at
+     * the construction site, so a second scope cannot appear by typo.
+     *
+     * @generated from field: string scope_code = 2;
+     */
+    scopeCode: string;
+    /**
+     * The hard cap. Published so a client can plan against it rather than
+     * discover it by being refused.
+     *
+     * @generated from field: uint32 max_spans = 3;
+     */
+    maxSpans: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceSpanPopulationBoundaryV1.
+ * Use `create(TraceSpanPopulationBoundaryV1Schema)` to create a new message.
+ */
+export declare const TraceSpanPopulationBoundaryV1Schema: GenMessage<TraceSpanPopulationBoundaryV1>;
+/**
+ * The window actually read, and whether it is the window that was asked for.
+ *
+ * The §4 invariant is "clamped windows say so in-band". `ListSessions` clamps
+ * to 720h silently and the only record of it is a fixture case name; this
+ * surface publishes the clamp, because a client rendering "no spans" must be
+ * able to tell "your window was narrowed" from "there is nothing there".
+ *
+ * @generated from message o11y_one.agentic.v1.TraceWindowV1
+ */
+export type TraceWindowV1 = Message<"o11y_one.agentic.v1.TraceWindowV1"> & {
+    /**
+     * @generated from field: google.protobuf.Timestamp start = 1;
+     */
+    start?: Timestamp | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp end = 2;
+     */
+    end?: Timestamp | undefined;
+    /**
+     * @generated from field: bool clamped = 3;
+     */
+    clamped: boolean;
+    /**
+     * Set only when `clamped` is true.
+     *
+     * @generated from field: optional string clamp_reason_code = 4;
+     */
+    clampReasonCode?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceWindowV1.
+ * Use `create(TraceWindowV1Schema)` to create a new message.
+ */
+export declare const TraceWindowV1Schema: GenMessage<TraceWindowV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.TraceReadRefusalV1
+ */
+export type TraceReadRefusalV1 = Message<"o11y_one.agentic.v1.TraceReadRefusalV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceReadRefusalKindV1 kind = 1;
+     */
+    kind: TraceReadRefusalKindV1;
+    /**
+     * A typed slug rather than prose, because a client renders or groups by it.
+     *
+     * @generated from field: string reason_code = 2;
+     */
+    reasonCode: string;
+    /**
+     * @generated from field: string detail = 3;
+     */
+    detail: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.RecoveryActionV1 recovery_action = 4;
+     */
+    recoveryAction: RecoveryActionV1;
+    /**
+     * On a cap breach this is honestly `cap + 1` and means "at least this many":
+     * the scan deliberately stopped counting, and a fabricated exact total would
+     * be a number nobody measured.
+     *
+     * @generated from field: uint32 observed_span_count = 5;
+     */
+    observedSpanCount: number;
+    /**
+     * @generated from field: uint32 cap = 6;
+     */
+    cap: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceReadRefusalV1.
+ * Use `create(TraceReadRefusalV1Schema)` to create a new message.
+ */
+export declare const TraceReadRefusalV1Schema: GenMessage<TraceReadRefusalV1>;
+/**
+ * How many spans failed with one category.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceFaultCategoryCountV1
+ */
+export type TraceFaultCategoryCountV1 = Message<"o11y_one.agentic.v1.TraceFaultCategoryCountV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceFaultCategoryV1 category = 1;
+     */
+    category: TraceFaultCategoryV1;
+    /**
+     * @generated from field: uint32 span_count = 2;
+     */
+    spanCount: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceFaultCategoryCountV1.
+ * Use `create(TraceFaultCategoryCountV1Schema)` to create a new message.
+ */
+export declare const TraceFaultCategoryCountV1Schema: GenMessage<TraceFaultCategoryCountV1>;
+/**
+ * How many spans reported one status. Over the WHOLE member set, not only the
+ * failures — a step whose spans are 40 OK and 2 UNSET is telling a reader
+ * something an error count cannot.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceFaultStatusCountV1
+ */
+export type TraceFaultStatusCountV1 = Message<"o11y_one.agentic.v1.TraceFaultStatusCountV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceSpanStatusV1 status = 1;
+     */
+    status: TraceSpanStatusV1;
+    /**
+     * @generated from field: uint32 span_count = 2;
+     */
+    spanCount: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceFaultStatusCountV1.
+ * Use `create(TraceFaultStatusCountV1Schema)` to create a new message.
+ */
+export declare const TraceFaultStatusCountV1Schema: GenMessage<TraceFaultStatusCountV1>;
+/**
+ * The composition of a failure count (wave 35, lane B).
+ *
+ * Rides both `TraceStepSummaryV1` and `TraceOperationGroupV1`: a fault
+ * breakdown per turn and per operation group is the same arithmetic over a
+ * different member set, and two messages would be two places for that rule to
+ * drift.
+ *
+ * It deliberately does NOT restate `failure_count` — that number is already on
+ * both parents, and a breakdown carrying its own copy is one edit away from
+ * disagreeing with the count printed beside it. Everything here is the
+ * composition OF that count, plus the two exception facts a boolean per span
+ * could not aggregate.
+ *
+ * There is no `timeout_count` field either. A timeout is
+ * `category_counts[TIMEOUT]`, and minting a second spelling of one fact on one
+ * message is how two renderings of one screen come to disagree.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceFaultBreakdownV1
+ */
+export type TraceFaultBreakdownV1 = Message<"o11y_one.agentic.v1.TraceFaultBreakdownV1"> & {
+    /**
+     * Spans that recorded at least one exception event, failing or not.
+     *
+     * @generated from field: uint32 exception_event_span_count = 1;
+     */
+    exceptionEventSpanCount: number;
+    /**
+     * The SUM of the spans' `exception_count` columns — how many exceptions were
+     * recorded, not how many spans recorded one. A span that threw four times is
+     * four here and one above.
+     *
+     * @generated from field: uint32 exception_event_count = 2;
+     */
+    exceptionEventCount: number;
+    /**
+     * NOT_OBSERVED with `span_plane_states_no_exception_count` when NO member
+     * carried the column at all. Distinct from every member carrying zero, which
+     * is an honest zero and reports AVAILABLE.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 exception_event_count_availability = 3;
+     */
+    exceptionEventCountAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * Spans that recorded an exception and did NOT fail — the WARN attention
+     * kind, counted here so the step strip and the needs-attention set agree by
+     * construction rather than by coincidence.
+     *
+     * @generated from field: uint32 warned_span_count = 4;
+     */
+    warnedSpanCount: number;
+    /**
+     * Over the FAILING members only, descending by count then by enum value.
+     * Sums to the `failure_count` on the parent message; a failing span whose
+     * category column is null counts as `UNCLASSIFIED`.
+     *
+     * @generated from field: repeated o11y_one.agentic.v1.TraceFaultCategoryCountV1 category_counts = 5;
+     */
+    categoryCounts: TraceFaultCategoryCountV1[];
+    /**
+     * Over ALL members, ascending by enum value. Sums to the member count.
+     *
+     * @generated from field: repeated o11y_one.agentic.v1.TraceFaultStatusCountV1 status_counts = 6;
+     */
+    statusCounts: TraceFaultStatusCountV1[];
+    /**
+     * Failing members over all members, in basis points.
+     *
+     * Read this convention carefully, because it is NOT the one
+     * `wall_time_share_basis_points` uses. That share deliberately does not
+     * normalise to 10000, so that concurrency stays visible. This one is a true
+     * fraction of its own population and is always in [0, 10000].
+     *
+     * @generated from field: optional uint32 fault_share_basis_points = 7;
+     */
+    faultShareBasisPoints?: number | undefined;
+    /**
+     * NOT_OBSERVED with `population_carries_no_spans` when the member set is
+     * empty. An empty population has no fault share; it does not have a zero one.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 fault_share_availability = 8;
+     */
+    faultShareAvailability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceFaultBreakdownV1.
+ * Use `create(TraceFaultBreakdownV1Schema)` to create a new message.
+ */
+export declare const TraceFaultBreakdownV1Schema: GenMessage<TraceFaultBreakdownV1>;
+/**
+ * The first thing that went wrong in a turn.
+ *
+ * The failing member with the earliest start, span id ascending as the
+ * tiebreak — the same order this whole surface pages by, so "first" means the
+ * same thing here as it does everywhere else.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceFirstFailureV1
+ */
+export type TraceFirstFailureV1 = Message<"o11y_one.agentic.v1.TraceFirstFailureV1"> & {
+    /**
+     * @generated from field: string span_id = 1;
+     */
+    spanId: string;
+    /**
+     * @generated from field: string span_name = 2;
+     */
+    spanName: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceFaultCategoryV1 category = 3;
+     */
+    category: TraceFaultCategoryV1;
+    /**
+     * @generated from field: google.protobuf.Timestamp started_at = 4;
+     */
+    startedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: int64 duration_micros = 5;
+     */
+    durationMicros: bigint;
+    /**
+     * @generated from field: optional string error_type = 6;
+     */
+    errorType?: string | undefined;
+    /**
+     * @generated from field: optional string error_message = 7;
+     */
+    errorMessage?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceFirstFailureV1.
+ * Use `create(TraceFirstFailureV1Schema)` to create a new message.
+ */
+export declare const TraceFirstFailureV1Schema: GenMessage<TraceFirstFailureV1>;
+/**
+ * The list row an estimate was priced from, and the date it was read.
+ *
+ * This message exists so the client's tooltip can say a true sentence:
+ * *"estimated from the provider's pricing list, as of <rate_checked_at>"*. A
+ * cost with no rate identity beside it is a number nobody can check.
+ *
+ * What it deliberately does NOT carry is a provider. `ProviderUsageRecordV1` on
+ * the span beside it sets `provider = UNSPECIFIED` on purpose (NN5): a span
+ * names its provider, when it names one at all, in free text, and mapping that
+ * onto this build's closed enum would put a provider-attributed fact on the
+ * wire the provider never stated. The estimate does not need one — the SPAN
+ * states its own model id, and that string is matched to a registry row by
+ * EXACT model id. The rate identity is a row, not an attribution.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceSpanRateBasisV1
+ */
+export type TraceSpanRateBasisV1 = Message<"o11y_one.agentic.v1.TraceSpanRateBasisV1"> & {
+    /**
+     * The model id the span itself stated (response model first — the model that
+     * served is the model billed), matched to a registry row by exact equality.
+     *
+     * @generated from field: string model_id = 1;
+     */
+    modelId: string;
+    /**
+     * The registry's version and table-wide review date.
+     *
+     * @generated from field: string registry_version = 2;
+     */
+    registryVersion: string;
+    /**
+     * @generated from field: string registry_effective_date = 3;
+     */
+    registryEffectiveDate: string;
+    /**
+     * THIS ROW's own as-of date — when these numbers were last read off the
+     * provider's page. Per-row rather than table-wide, which is the whole point
+     * of increment E1-5: a table-wide date claims every row was reviewed on one
+     * day. THIS is the date the tooltip renders.
+     *
+     * @generated from field: string rate_checked_at = 4;
+     */
+    rateCheckedAt: string;
+    /**
+     * The age at which the registry calls itself stale, in days.
+     *
+     * The THRESHOLD and no verdict, and that is the same ruling `capability.rs`
+     * made for the rate-freshness posture (increment E1-6, narrowed by wave 25):
+     * a staleness state is `observed_at - effective_date`, which changes every
+     * midnight, and this message rides responses the fixture corpus asserts byte
+     * for byte. A verdict here would turn the corpus red on one future calendar
+     * day with no code change. So this publishes the compiled-in facts — which
+     * table, which row, when a human last re-read it, and the rule's threshold —
+     * and lets the client, which has its own clock, apply the rule. The eval
+     * side's frozen verdict still lives where a verdict belongs: on
+     * `EvaluationPricingSourceV1`, computed at the single instant a pricing pass
+     * reads, and sealed into an immutable manifest.
+     *
+     * @generated from field: uint32 staleness_threshold_days = 5;
+     */
+    stalenessThresholdDays: number;
+    /**
+     * The two dimensions this estimate actually priced. Absent means the row
+     * publishes no price for that dimension, never a zero price.
+     *
+     * @generated from field: optional int64 input_micros_per_million_tokens = 6;
+     */
+    inputMicrosPerMillionTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 output_micros_per_million_tokens = 7;
+     */
+    outputMicrosPerMillionTokens?: bigint | undefined;
+    /**
+     * The same accounting block the span's usage record carries, and it says the
+     * same thing: `provider_accounting_unknown`. It is the field that explains
+     * the dimension notes below — with no provider named, this build cannot know
+     * whether the span's input tokens already contain its cache tokens, and the
+     * two providers it ships answer that question OPPOSITELY.
+     *
+     * @generated from field: o11y_one.agentic.v1.EvaluationTokenAccountingV1 token_accounting = 8;
+     */
+    tokenAccounting?: EvaluationTokenAccountingV1 | undefined;
+    /**
+     * One note per dimension this estimate declined to price, with the reason.
+     * An estimate that names what it left out is arguable; one that silently
+     * double-counts a cache is not. Reuses the eval side's note type rather than
+     * twinning it.
+     *
+     * @generated from field: repeated o11y_one.agentic.v1.EvaluationRateDimensionNoteV1 dimension_notes = 9;
+     */
+    dimensionNotes: EvaluationRateDimensionNoteV1[];
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceSpanRateBasisV1.
+ * Use `create(TraceSpanRateBasisV1Schema)` to create a new message.
+ */
+export declare const TraceSpanRateBasisV1Schema: GenMessage<TraceSpanRateBasisV1>;
+/**
+ * Level 4b. One span's cost, with its provenance stated (wave 35, lane B).
+ *
+ * HARD BOUNDARY, stated on the wire because it is the property that makes this
+ * message safe to ship: this number is DISPLAY PLANE ONLY. It enters no
+ * economics ledger, no projection, no invoice surface and no run manifest; it
+ * is never summed with evaluation economics; and it is never what the provider
+ * billed. The eval side's costs are frozen into immutable manifests and
+ * reserved against budgets. This one is read off a telemetry span at render
+ * time and is gone when the window closes.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceSpanCostV1
+ */
+export type TraceSpanCostV1 = Message<"o11y_one.agentic.v1.TraceSpanCostV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceSpanCostProvenanceV1 provenance = 1;
+     */
+    provenance: TraceSpanCostProvenanceV1;
+    /**
+     * Integer micros, in the currency named beside it. Absent whenever the
+     * availability is not AVAILABLE — a cost this build could not determine is
+     * absent, never zero.
+     *
+     * @generated from field: optional o11y_one.agentic.v1.CostAmountV1 amount = 2;
+     */
+    amount?: CostAmountV1 | undefined;
+    /**
+     * The span's own spelling of its cost attribute, byte for byte, whenever the
+     * span carried one — INCLUDING when it did not parse as a number. The
+     * verbatim string is evidence; the micros beside it are a scale of that
+     * evidence, and if the two ever disagree the string is the one that is true.
+     *
+     * @generated from field: optional string client_stated_amount_verbatim = 3;
+     */
+    clientStatedAmountVerbatim?: string | undefined;
+    /**
+     * Set only for LIST_RATE_ESTIMATE.
+     *
+     * @generated from field: optional o11y_one.agentic.v1.TraceSpanRateBasisV1 rate_basis = 4;
+     */
+    rateBasis?: TraceSpanRateBasisV1 | undefined;
+    /**
+     * Why there is no amount, when there is none. One of:
+     * `span_states_no_cost_and_no_token_usage`,
+     * `span_states_no_input_output_token_split`, `span_states_no_model_id`,
+     * `no_list_rate_for_span_model`, `span_cost_attribute_is_not_a_number`,
+     * `residual_attributes_not_presented_by_plane`.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 5;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+    /**
+     * Whether the currency of this amount is a stated fact.
+     *
+     * `gen_ai.usage.cost` is a bare number: OTel gives it no currency companion
+     * and this build recognises none. So a CLIENT_STATED amount reports
+     * NOT_OBSERVED with `span_states_cost_without_currency` and an empty
+     * `currency_code`, rather than being stamped "USD" by a server that was never
+     * told. A LIST_RATE_ESTIMATE reports AVAILABLE: the registry denominates its
+     * own rows.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 currency_availability = 6;
+     */
+    currencyAvailability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceSpanCostV1.
+ * Use `create(TraceSpanCostV1Schema)` to create a new message.
+ */
+export declare const TraceSpanCostV1Schema: GenMessage<TraceSpanCostV1>;
+/**
+ * A group's cost, and what it is made of.
+ *
+ * Rides `TraceOperationGroupV1` and nothing else. A group is the same operation
+ * against the same target ×N, which is the one place a sum answers a question a
+ * person actually asks. There is deliberately NO step-level and NO trace-level
+ * total: a trace-wide money total is a bill-shaped object, and a bill-shaped
+ * object on a telemetry read model is how a display-plane estimate ends up
+ * quoted at somebody. A client that wants one can add these up in front of a
+ * person who can see what they are adding.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceSpanCostRollupV1
+ */
+export type TraceSpanCostRollupV1 = Message<"o11y_one.agentic.v1.TraceSpanCostRollupV1"> & {
+    /**
+     * Present only when at least one member carries an amount. Never a zero
+     * standing in for "nothing here was costed".
+     *
+     * @generated from field: optional o11y_one.agentic.v1.CostAmountV1 total = 1;
+     */
+    total?: CostAmountV1 | undefined;
+    /**
+     * NOT_OBSERVED with `no_span_in_group_carries_cost` when no member had one.
+     * AVAILABLE with reason `rollup_mixes_unstated_currency` when the total
+     * includes a client-stated member whose currency the span never stated — in
+     * which case `total.currency_code` is empty, because the sum is denominated
+     * in at least one currency nobody named.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 2;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+    /**
+     * @generated from field: uint32 client_stated_span_count = 3;
+     */
+    clientStatedSpanCount: number;
+    /**
+     * @generated from field: uint32 list_rate_estimate_span_count = 4;
+     */
+    listRateEstimateSpanCount: number;
+    /**
+     * @generated from field: uint32 uncosted_span_count = 5;
+     */
+    uncostedSpanCount: number;
+    /**
+     * True when the total adds a stated number to an estimated one. Such a total
+     * is a different kind of number from either of its parts and must not render
+     * as though it were one of them.
+     *
+     * @generated from field: bool mixes_stated_and_estimated = 6;
+     */
+    mixesStatedAndEstimated: boolean;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceSpanCostRollupV1.
+ * Use `create(TraceSpanCostRollupV1Schema)` to create a new message.
+ */
+export declare const TraceSpanCostRollupV1Schema: GenMessage<TraceSpanCostRollupV1>;
+/**
+ * One member of a group that is slower than its group's p95.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceSpanOutlierV1
+ */
+export type TraceSpanOutlierV1 = Message<"o11y_one.agentic.v1.TraceSpanOutlierV1"> & {
+    /**
+     * @generated from field: string span_id = 1;
+     */
+    spanId: string;
+    /**
+     * @generated from field: string span_name = 2;
+     */
+    spanName: string;
+    /**
+     * @generated from field: int64 duration_micros = 3;
+     */
+    durationMicros: bigint;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceSpanOutlierV1.
+ * Use `create(TraceSpanOutlierV1Schema)` to create a new message.
+ */
+export declare const TraceSpanOutlierV1Schema: GenMessage<TraceSpanOutlierV1>;
+/**
+ * Level 2. Operations of one kind against one target, collapsed.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceOperationGroupV1
+ */
+export type TraceOperationGroupV1 = Message<"o11y_one.agentic.v1.TraceOperationGroupV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceOperationKindV1 kind = 1;
+     */
+    kind: TraceOperationKindV1;
+    /**
+     * The most specific identifier the span carries for its kind: the tool name
+     * or MCP method for TOOL, the response then request model for LLM,
+     * `db.system.name` for DB, `http.route` then `url.path` for HTTP, the service
+     * name then the span name otherwise. Never empty — an empty group key would
+     * collapse unlike operations into one row.
+     *
+     * @generated from field: string target = 2;
+     */
+    target: string;
+    /**
+     * The design's "×N collapse count".
+     *
+     * @generated from field: uint32 collapsed_count = 3;
+     */
+    collapsedCount: number;
+    /**
+     * @generated from field: uint32 failure_count = 4;
+     */
+    failureCount: number;
+    /**
+     * The design's "Σ duration": the SUM of member durations, which for
+     * concurrent members exceeds wall time. Named `total_duration` and not
+     * `wall_time` for exactly that reason.
+     *
+     * @generated from field: int64 total_duration_micros = 5;
+     */
+    totalDurationMicros: bigint;
+    /**
+     * Nearest rank: sort ascending, take index `ceil(0.95 * n) - 1`.
+     *
+     * Absent for a group smaller than `min_group_size_for_percentile`, because a
+     * p95 over four samples is the maximum wearing a percentile's name — and the
+     * maximum of a one-member group is that member, which would make every single
+     * call an "outlier".
+     *
+     * @generated from field: optional int64 p95_duration_micros = 6;
+     */
+    p95DurationMicros?: bigint | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 p95_availability = 7;
+     */
+    p95Availability?: MetricAvailabilityV1 | undefined;
+    /**
+     * Members strictly slower than p95, slowest first, capped. Empty whenever
+     * p95 is absent.
+     *
+     * @generated from field: repeated o11y_one.agentic.v1.TraceSpanOutlierV1 outliers = 8;
+     */
+    outliers: TraceSpanOutlierV1[];
+    /**
+     * How many further outliers the cap dropped. A full outlier list is never
+     * read as a complete one.
+     *
+     * @generated from field: uint32 omitted_outlier_count = 9;
+     */
+    omittedOutlierCount: number;
+    /**
+     * Wave 35. The composition of `failure_count` above: which categories, which
+     * statuses, how many exceptions.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceFaultBreakdownV1 faults = 10;
+     */
+    faults?: TraceFaultBreakdownV1 | undefined;
+    /**
+     * Wave 35. What these ×N calls cost, and how that number was arrived at.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceSpanCostRollupV1 cost = 11;
+     */
+    cost?: TraceSpanCostRollupV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceOperationGroupV1.
+ * Use `create(TraceOperationGroupV1Schema)` to create a new message.
+ */
+export declare const TraceOperationGroupV1Schema: GenMessage<TraceOperationGroupV1>;
+/**
+ * Level 1. One agent turn.
+ *
+ * A step is a span carrying `gen_ai.agent.name` no ancestor of which carries
+ * one; every other span attributes to its nearest such ancestor. There is no
+ * `invoke_agent` operation-name convention in this build, so keying on one
+ * would be keying on something nothing emits.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceStepSummaryV1
+ */
+export type TraceStepSummaryV1 = Message<"o11y_one.agentic.v1.TraceStepSummaryV1"> & {
+    /**
+     * The turn's own span id. A step IS a span; it does not get a synthetic id.
+     *
+     * @generated from field: string step_id = 1;
+     */
+    stepId: string;
+    /**
+     * @generated from field: string step_name = 2;
+     */
+    stepName: string;
+    /**
+     * @generated from field: optional string agent_name = 3;
+     */
+    agentName?: string | undefined;
+    /**
+     * @generated from field: optional string agent_id = 4;
+     */
+    agentId?: string | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp started_at = 5;
+     */
+    startedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp ended_at = 6;
+     */
+    endedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: int64 wall_time_micros = 7;
+     */
+    wallTimeMicros: bigint;
+    /**
+     * Basis points of the trace's wall time, so two clients render the same
+     * number. Shares deliberately DO NOT sum to 10000 when steps overlap or when
+     * spans are unattributed: a normalised share would hide concurrency, which is
+     * the fact a waterfall exists to show.
+     *
+     * @generated from field: optional uint32 wall_time_share_basis_points = 8;
+     */
+    wallTimeShareBasisPoints?: number | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 wall_time_share_availability = 9;
+     */
+    wallTimeShareAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * Spans attributed to this step, excluding the step span itself.
+     *
+     * @generated from field: uint32 operation_count = 10;
+     */
+    operationCount: number;
+    /**
+     * Failing spans attributed to this step, INCLUDING the step span itself if it
+     * failed — a turn that failed is a failure of that turn.
+     *
+     * @generated from field: uint32 failure_count = 11;
+     */
+    failureCount: number;
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.TraceOperationGroupV1 operation_groups = 12;
+     */
+    operationGroups: TraceOperationGroupV1[];
+    /**
+     * @generated from field: uint32 omitted_operation_group_count = 13;
+     */
+    omittedOperationGroupCount: number;
+    /**
+     * Wave 35. The composition of `failure_count` above, over this turn's spans
+     * INCLUDING the turn's own span — the same member set the count uses, for the
+     * same reason: a turn that failed is a failure of that turn.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceFaultBreakdownV1 faults = 14;
+     */
+    faults?: TraceFaultBreakdownV1 | undefined;
+    /**
+     * Wave 35. The earliest failure in this turn. Absent when the turn had none —
+     * absent, not a zero-valued pointer at a span that did not fail.
+     *
+     * @generated from field: optional o11y_one.agentic.v1.TraceFirstFailureV1 first_failure = 15;
+     */
+    firstFailure?: TraceFirstFailureV1 | undefined;
+    /**
+     * S2. What this turn cost, over the SAME member set `failure_count` and
+     * `faults` use — the turn's spans INCLUDING the turn's own span, because a
+     * turn's money is the money of that turn. It is therefore NOT the sum of
+     * `operation_groups`' rollups whenever the turn's own span carries a cost:
+     * the groups exclude that span, for the same reason `operation_count` does.
+     *
+     * Same type as a group's rollup, so `mixes_stated_and_estimated` and the
+     * unstated-currency reason ride the turn total too: a total that adds a
+     * client's own figure to a list-rate estimate is labelled, not hidden.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceSpanCostRollupV1 cost = 16;
+     */
+    cost?: TraceSpanCostRollupV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceStepSummaryV1.
+ * Use `create(TraceStepSummaryV1Schema)` to create a new message.
+ */
+export declare const TraceStepSummaryV1Schema: GenMessage<TraceStepSummaryV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.TraceCriticalPathStepV1
+ */
+export type TraceCriticalPathStepV1 = Message<"o11y_one.agentic.v1.TraceCriticalPathStepV1"> & {
+    /**
+     * @generated from field: string span_id = 1;
+     */
+    spanId: string;
+    /**
+     * @generated from field: string span_name = 2;
+     */
+    spanName: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceOperationKindV1 kind = 3;
+     */
+    kind: TraceOperationKindV1;
+    /**
+     * @generated from field: int64 duration_micros = 4;
+     */
+    durationMicros: bigint;
+    /**
+     * Duration minus the UNION of the children's intervals, so a span with two
+     * concurrent children is not charged twice. This is the number that says
+     * which link is spending time rather than merely containing it.
+     *
+     * @generated from field: int64 self_duration_micros = 5;
+     */
+    selfDurationMicros: bigint;
+    /**
+     * @generated from field: uint32 depth = 6;
+     */
+    depth: number;
+    /**
+     * @generated from field: optional string step_id = 7;
+     */
+    stepId?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceCriticalPathStepV1.
+ * Use `create(TraceCriticalPathStepV1Schema)` to create a new message.
+ */
+export declare const TraceCriticalPathStepV1Schema: GenMessage<TraceCriticalPathStepV1>;
+/**
+ * Level 5a. The chain that determines the trace's wall time.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceCriticalPathV1
+ */
+export type TraceCriticalPathV1 = Message<"o11y_one.agentic.v1.TraceCriticalPathV1"> & {
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.TraceCriticalPathStepV1 steps = 1;
+     */
+    steps: TraceCriticalPathStepV1[];
+    /**
+     * The ROOT's duration, not the sum of the chain — a sum would double-count
+     * every nesting level.
+     *
+     * @generated from field: int64 total_duration_micros = 2;
+     */
+    totalDurationMicros: bigint;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 3;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+    /**
+     * Which definition produced this path. A client that renders "the critical
+     * path" without knowing the definition cannot compare two builds, and a later
+     * change of definition should be a fixture diff a reviewer sees.
+     *
+     * `latest_finishing_child_chain_v1`: from the root, repeatedly descend to the
+     * child whose end time is latest; ties by longer duration, then by span id
+     * ascending, so the answer is deterministic.
+     *
+     * @generated from field: string method_code = 4;
+     */
+    methodCode: string;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceCriticalPathV1.
+ * Use `create(TraceCriticalPathV1Schema)` to create a new message.
+ */
+export declare const TraceCriticalPathV1Schema: GenMessage<TraceCriticalPathV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.TraceAttentionItemV1
+ */
+export type TraceAttentionItemV1 = Message<"o11y_one.agentic.v1.TraceAttentionItemV1"> & {
+    /**
+     * @generated from field: string span_id = 1;
+     */
+    spanId: string;
+    /**
+     * @generated from field: string span_name = 2;
+     */
+    spanName: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceAttentionKindV1 kind = 3;
+     */
+    kind: TraceAttentionKindV1;
+    /**
+     * @generated from field: string reason_code = 4;
+     */
+    reasonCode: string;
+    /**
+     * @generated from field: optional string detail = 5;
+     */
+    detail?: string | undefined;
+    /**
+     * @generated from field: int64 duration_micros = 6;
+     */
+    durationMicros: bigint;
+    /**
+     * @generated from field: optional string step_id = 7;
+     */
+    stepId?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceAttentionItemV1.
+ * Use `create(TraceAttentionItemV1Schema)` to create a new message.
+ */
+export declare const TraceAttentionItemV1Schema: GenMessage<TraceAttentionItemV1>;
+/**
+ * Level 5b. What "Highlight errors" filters over, computed here so it is not a
+ * client scan.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceNeedsAttentionSetV1
+ */
+export type TraceNeedsAttentionSetV1 = Message<"o11y_one.agentic.v1.TraceNeedsAttentionSetV1"> & {
+    /**
+     * Sorted ERROR, then WARN, then SLOW_OUTLIER; within a kind by duration
+     * descending, then span id.
+     *
+     * @generated from field: repeated o11y_one.agentic.v1.TraceAttentionItemV1 items = 1;
+     */
+    items: TraceAttentionItemV1[];
+    /**
+     * The three counts are over the WHOLE population, not over the capped list
+     * above, so a client that renders "1,204 errors" while showing 200 of them is
+     * telling the truth on both numbers.
+     *
+     * @generated from field: uint32 error_count = 2;
+     */
+    errorCount: number;
+    /**
+     * @generated from field: uint32 warn_count = 3;
+     */
+    warnCount: number;
+    /**
+     * @generated from field: uint32 slow_outlier_count = 4;
+     */
+    slowOutlierCount: number;
+    /**
+     * @generated from field: uint32 omitted_item_count = 5;
+     */
+    omittedItemCount: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceNeedsAttentionSetV1.
+ * Use `create(TraceNeedsAttentionSetV1Schema)` to create a new message.
+ */
+export declare const TraceNeedsAttentionSetV1Schema: GenMessage<TraceNeedsAttentionSetV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.AgentTraceHeaderV1
+ */
+export type AgentTraceHeaderV1 = Message<"o11y_one.agentic.v1.AgentTraceHeaderV1"> & {
+    /**
+     * @generated from field: string trace_id = 1;
+     */
+    traceId: string;
+    /**
+     * @generated from field: google.protobuf.Timestamp started_at = 2;
+     */
+    startedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp ended_at = 3;
+     */
+    endedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: int64 wall_time_micros = 4;
+     */
+    wallTimeMicros: bigint;
+    /**
+     * @generated from field: uint32 span_count = 5;
+     */
+    spanCount: number;
+    /**
+     * @generated from field: uint32 step_count = 6;
+     */
+    stepCount: number;
+    /**
+     * Spans with no agent-turn ancestor. Never silently folded into a
+     * neighbouring step.
+     *
+     * @generated from field: uint32 unattributed_span_count = 7;
+     */
+    unattributedSpanCount: number;
+    /**
+     * AVAILABLE when at least one agent turn was found — including when the
+     * count of anything under it is honestly zero. NOT_OBSERVED with
+     * `trace_carries_no_agent_turn_spans` when the trace's spans carry no
+     * `gen_ai.agent.name` at all, which is a different fact from a trace whose
+     * turns did nothing.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 step_availability = 8;
+     */
+    stepAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * S2. What the whole trace cost, over EVERY span in the population — the
+     * turns, their operations, and the spans that attribute to no turn. Over the
+     * whole population rather than over the steps because a trace whose LLM calls
+     * carry no `gen_ai.agent.name` has no steps at all, and a money total that
+     * read zero there would be reporting the absence of turns as the absence of
+     * spend.
+     *
+     * Same type as a step's and a group's rollup, so the composition counts, the
+     * `mixes_stated_and_estimated` flag and the unstated-currency reason ride the
+     * trace total too. A partial-provenance total is labelled, not hidden.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceSpanCostRollupV1 cost = 9;
+     */
+    cost?: TraceSpanCostRollupV1 | undefined;
+    /**
+     * S3. Spans that exist only because an earlier attempt failed: members of an
+     * inferred retry chain whose `attempt_index` is greater than one. An honest
+     * zero — the population was read and no chain was found — which is why it is
+     * a count here and an absence on the span.
+     *
+     * @generated from field: uint32 retried_span_count = 10;
+     */
+    retriedSpanCount: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentTraceHeaderV1.
+ * Use `create(AgentTraceHeaderV1Schema)` to create a new message.
+ */
+export declare const AgentTraceHeaderV1Schema: GenMessage<AgentTraceHeaderV1>;
+/**
+ * A span's input and output as this build actually holds them: storage
+ * references, not bodies.
+ *
+ * Present so the absence is legible rather than implied. Turning one of these
+ * into a payload is the Phase 5 "Extraction Preview" plane — redaction before
+ * preview, dedupe fingerprints, leakage signals — and the capability
+ * `trace_span_content_hydration` says it is UNAVAILABLE.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceSpanContentRefV1
+ */
+export type TraceSpanContentRefV1 = Message<"o11y_one.agentic.v1.TraceSpanContentRefV1"> & {
+    /**
+     * `input`, `output`, `tool_arguments`, `tool_result`, `retrieval_documents`,
+     * `reasoning`.
+     *
+     * @generated from field: string content_class = 1;
+     */
+    contentClass: string;
+    /**
+     * @generated from field: string storage_uri = 2;
+     */
+    storageUri: string;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceSpanContentRefV1.
+ * Use `create(TraceSpanContentRefV1Schema)` to create a new message.
+ */
+export declare const TraceSpanContentRefV1Schema: GenMessage<TraceSpanContentRefV1>;
+/**
+ * S3. One span's place in a retry chain.
+ *
+ * INFERRED, and the capability says so. Nothing in this build marks a span as a
+ * retry of another: no `retry`, `resend` or `attempt` key reaches a typed
+ * column, and span links arrive at the lake with their ATTRIBUTES DROPPED, so
+ * OTel's own relational mechanism cannot say WHY it links. What is left is the
+ * shape — one parent, one name, one kind, one target, non-overlapping in time,
+ * every attempt but the last in error — and `trace_view_retry_chain` publishes
+ * `retry_chain_inference = 1` so a client renders this as a reading of the
+ * trace rather than as something the caller reported.
+ *
+ * Absent on a span that is in no chain. Never a one-attempt chain, and never a
+ * zero standing in for "this call was made once".
+ *
+ * @generated from message o11y_one.agentic.v1.TraceSpanRetryV1
+ */
+export type TraceSpanRetryV1 = Message<"o11y_one.agentic.v1.TraceSpanRetryV1"> & {
+    /**
+     * The parent span id, the operation kind, the span name and the target,
+     * joined. It is the grouping key itself, so two spans carry one id exactly
+     * when they are in one chain. Deterministic, so two reads of one trace name
+     * the chain identically and a fixture is byte-stable. The kind and the target
+     * are in it because two sibling groups can share a name and differ only in
+     * the kind, or only in the model or tool they called. Key by it; it is not
+     * meant to be parsed.
+     *
+     * @generated from field: string chain_id = 1;
+     */
+    chainId: string;
+    /**
+     * 1-based. The first attempt is attempt 1, not a retry of anything.
+     *
+     * @generated from field: uint32 attempt_index = 2;
+     */
+    attemptIndex: number;
+    /**
+     * Attempts in this chain, including the one that finally succeeded. A chain
+     * whose last attempt also failed is a chain that never succeeded, and this
+     * count does not say which — `status` on each member does.
+     *
+     * @generated from field: uint32 attempt_count = 3;
+     */
+    attemptCount: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceSpanRetryV1.
+ * Use `create(TraceSpanRetryV1Schema)` to create a new message.
+ */
+export declare const TraceSpanRetryV1Schema: GenMessage<TraceSpanRetryV1>;
+/**
+ * Level 3. One raw span row.
+ *
+ * @generated from message o11y_one.agentic.v1.TraceSpanV1
+ */
+export type TraceSpanV1 = Message<"o11y_one.agentic.v1.TraceSpanV1"> & {
+    /**
+     * @generated from field: string span_id = 1;
+     */
+    spanId: string;
+    /**
+     * @generated from field: optional string parent_span_id = 2;
+     */
+    parentSpanId?: string | undefined;
+    /**
+     * The agent turn this span attributes to. Absent for an unattributed span.
+     *
+     * @generated from field: optional string step_id = 3;
+     */
+    stepId?: string | undefined;
+    /**
+     * @generated from field: string name = 4;
+     */
+    name: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceOperationKindV1 kind = 5;
+     */
+    kind: TraceOperationKindV1;
+    /**
+     * @generated from field: string target = 6;
+     */
+    target: string;
+    /**
+     * @generated from field: optional string service_name = 7;
+     */
+    serviceName?: string | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp started_at = 8;
+     */
+    startedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp ended_at = 9;
+     */
+    endedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: int64 duration_micros = 10;
+     */
+    durationMicros: bigint;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceSpanStatusV1 status = 11;
+     */
+    status: TraceSpanStatusV1;
+    /**
+     * @generated from field: bool is_error = 12;
+     */
+    isError: boolean;
+    /**
+     * @generated from field: optional string error_type = 13;
+     */
+    errorType?: string | undefined;
+    /**
+     * @generated from field: optional string error_message = 14;
+     */
+    errorMessage?: string | undefined;
+    /**
+     * @generated from field: bool has_exception_event = 15;
+     */
+    hasExceptionEvent: boolean;
+    /**
+     * Level 4. The span's usage object, preserved under the EVAL SIDE'S contract:
+     * the same `ProviderUsageRecordV1` type, the same 48-field / 96-byte-path /
+     * 64-byte-text / 4096-byte bounds, and the same rule that breaching any bound
+     * refuses the WHOLE record rather than truncating it. Those four numbers are
+     * imported from the eval side rather than restated here, because a second
+     * copy of them is a future disagreement.
+     *
+     * What CANNOT be reused is a provider body, and the record says so rather
+     * than letting a reader assume the stronger claim: the ingest pipeline
+     * normalises a provider's `usage` object into OTel-spelled columns before
+     * this surface sees a span, so `availability.provenance` is
+     * `otel_span_gen_ai_usage_attributes`. The record is verbatim with respect to
+     * the SPAN — every scalar leaf it carries, in the span's own spelling, sorted
+     * by path — and is not verbatim with respect to the provider.
+     *
+     * @generated from field: o11y_one.agentic.v1.ProviderUsageRecordV1 verbatim_usage = 16;
+     */
+    verbatimUsage?: ProviderUsageRecordV1 | undefined;
+    /**
+     * NOT_SUPPORTED with `non_streaming_provider_client`: this build's provider
+     * client does not stream, so there is no first-token instant to record. An
+     * availability, never a zero.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 time_to_first_token_availability = 17;
+     */
+    timeToFirstTokenAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.TraceSpanContentRefV1 content_refs = 18;
+     */
+    contentRefs: TraceSpanContentRefV1[];
+    /**
+     * Level 4b (wave 35). What this span cost, and where that number came from:
+     * the client's own instrumented figure, an estimate off the provider's
+     * published list price, or a typed absence. Display plane only — see
+     * `TraceSpanCostV1`.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceSpanCostV1 cost = 19;
+     */
+    cost?: TraceSpanCostV1 | undefined;
+    /**
+     * S3. Where this span sits in an inferred retry chain, or absent when it sits
+     * in none. See `TraceSpanRetryV1` for what "inferred" buys and costs.
+     *
+     * @generated from field: optional o11y_one.agentic.v1.TraceSpanRetryV1 retry = 20;
+     */
+    retry?: TraceSpanRetryV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceSpanV1.
+ * Use `create(TraceSpanV1Schema)` to create a new message.
+ */
+export declare const TraceSpanV1Schema: GenMessage<TraceSpanV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.GetAgentTraceDetailRequest
+ */
+export type GetAgentTraceDetailRequest = Message<"o11y_one.agentic.v1.GetAgentTraceDetailRequest"> & {
+    /**
+     * Lowercase hex, as `SessionV1.trace_ids` spells it.
+     *
+     * @generated from field: string trace_id = 1;
+     */
+    traceId: string;
+    /**
+     * Unset means the recent-24h default; a range wider than the maximum is
+     * clamped, and the clamp is reported in-band.
+     *
+     * @generated from field: optional google.protobuf.Timestamp start = 2;
+     */
+    start?: Timestamp | undefined;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp end = 3;
+     */
+    end?: Timestamp | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.GetAgentTraceDetailRequest.
+ * Use `create(GetAgentTraceDetailRequestSchema)` to create a new message.
+ */
+export declare const GetAgentTraceDetailRequestSchema: GenMessage<GetAgentTraceDetailRequest>;
+/**
+ * Levels 1, 2 and 5, folded from ONE bounded span scan.
+ *
+ * It embeds no span page: a detail that carried one would grow without bound as
+ * a trace filled. It is `SELECTED_DETAIL`, not a page.
+ *
+ * @generated from message o11y_one.agentic.v1.GetAgentTraceDetailResponse
+ */
+export type GetAgentTraceDetailResponse = Message<"o11y_one.agentic.v1.GetAgentTraceDetailResponse"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentTraceHeaderV1 header = 1;
+     */
+    header?: AgentTraceHeaderV1 | undefined;
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.TraceStepSummaryV1 steps = 2;
+     */
+    steps: TraceStepSummaryV1[];
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceCriticalPathV1 critical_path = 3;
+     */
+    criticalPath?: TraceCriticalPathV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceNeedsAttentionSetV1 needs_attention = 4;
+     */
+    needsAttention?: TraceNeedsAttentionSetV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceSpanPopulationBoundaryV1 boundary = 5;
+     */
+    boundary?: TraceSpanPopulationBoundaryV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceWindowV1 window = 6;
+     */
+    window?: TraceWindowV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.EvaluationFreshnessV1 freshness = 7;
+     */
+    freshness?: EvaluationFreshnessV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgenticEvaluationCapabilitiesV1 capabilities = 8;
+     */
+    capabilities?: AgenticEvaluationCapabilitiesV1 | undefined;
+    /**
+     * Set when the read refused. When set, every field above it carries its
+     * zero/empty value and none of them is an answer.
+     *
+     * @generated from field: optional o11y_one.agentic.v1.TraceReadRefusalV1 refusal = 9;
+     */
+    refusal?: TraceReadRefusalV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.GetAgentTraceDetailResponse.
+ * Use `create(GetAgentTraceDetailResponseSchema)` to create a new message.
+ */
+export declare const GetAgentTraceDetailResponseSchema: GenMessage<GetAgentTraceDetailResponse>;
+/**
+ * @generated from message o11y_one.agentic.v1.ListAgentTraceSpansRequest
+ */
+export type ListAgentTraceSpansRequest = Message<"o11y_one.agentic.v1.ListAgentTraceSpansRequest"> & {
+    /**
+     * @generated from field: string trace_id = 1;
+     */
+    traceId: string;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp start = 2;
+     */
+    start?: Timestamp | undefined;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp end = 3;
+     */
+    end?: Timestamp | undefined;
+    /**
+     * Defaulted and capped; see the `trace_view_span_page` capability limits.
+     *
+     * @generated from field: optional uint32 limit = 4;
+     */
+    limit?: number | undefined;
+    /**
+     * @generated from field: optional uint32 offset = 5;
+     */
+    offset?: number | undefined;
+    /**
+     * Server-side filters. "Highlight errors" is this field, which is the whole
+     * point of level 5 being server-computed: the client does not scan.
+     *
+     * @generated from field: optional string step_id = 6;
+     */
+    stepId?: string | undefined;
+    /**
+     * @generated from field: optional o11y_one.agentic.v1.TraceAttentionKindV1 attention_filter = 7;
+     */
+    attentionFilter?: TraceAttentionKindV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.ListAgentTraceSpansRequest.
+ * Use `create(ListAgentTraceSpansRequestSchema)` to create a new message.
+ */
+export declare const ListAgentTraceSpansRequestSchema: GenMessage<ListAgentTraceSpansRequest>;
+/**
+ * Levels 3 and 4.
+ *
+ * @generated from message o11y_one.agentic.v1.ListAgentTraceSpansResponse
+ */
+export type ListAgentTraceSpansResponse = Message<"o11y_one.agentic.v1.ListAgentTraceSpansResponse"> & {
+    /**
+     * Ordered by start time ascending, span id ascending as tiebreak — a
+     * server-fixed order, which is what makes an offset over it stable.
+     *
+     * @generated from field: repeated o11y_one.agentic.v1.TraceSpanV1 spans = 1;
+     */
+    spans: TraceSpanV1[];
+    /**
+     * Over the FILTERED population, not the page. A client asking for the error
+     * spans of a 10,000-span trace gets the error spans, a page of them, and the
+     * true total.
+     *
+     * @generated from field: uint32 total_matching_span_count = 2;
+     */
+    totalMatchingSpanCount: number;
+    /**
+     * @generated from field: bool has_more = 3;
+     */
+    hasMore: boolean;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceSpanPopulationBoundaryV1 boundary = 4;
+     */
+    boundary?: TraceSpanPopulationBoundaryV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceWindowV1 window = 5;
+     */
+    window?: TraceWindowV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.EvaluationFreshnessV1 freshness = 6;
+     */
+    freshness?: EvaluationFreshnessV1 | undefined;
+    /**
+     * @generated from field: optional o11y_one.agentic.v1.TraceReadRefusalV1 refusal = 7;
+     */
+    refusal?: TraceReadRefusalV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.ListAgentTraceSpansResponse.
+ * Use `create(ListAgentTraceSpansResponseSchema)` to create a new message.
+ */
+export declare const ListAgentTraceSpansResponseSchema: GenMessage<ListAgentTraceSpansResponse>;
+/**
+ * @generated from message o11y_one.agentic.v1.AgentRunOutcomeInputV1
+ */
+export type AgentRunOutcomeInputV1 = Message<"o11y_one.agentic.v1.AgentRunOutcomeInputV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunOutcomeInputKindV1 kind = 1;
+     */
+    kind: AgentRunOutcomeInputKindV1;
+    /**
+     * What this input saw. Zero is an honest zero here: the input WAS consulted.
+     *
+     * @generated from field: uint32 observed_count = 2;
+     */
+    observedCount: number;
+    /**
+     * Exactly one input in the list carries `true` — the rung that decided.
+     *
+     * @generated from field: bool contributed = 3;
+     */
+    contributed: boolean;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunOutcomeInputV1.
+ * Use `create(AgentRunOutcomeInputV1Schema)` to create a new message.
+ */
+export declare const AgentRunOutcomeInputV1Schema: GenMessage<AgentRunOutcomeInputV1>;
+/**
+ * The verdict, its inputs, and the name of the rule that produced it.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunOutcomeAssessmentV1
+ */
+export type AgentRunOutcomeAssessmentV1 = Message<"o11y_one.agentic.v1.AgentRunOutcomeAssessmentV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunOutcomeV1 outcome = 1;
+     */
+    outcome: AgentRunOutcomeV1;
+    /**
+     * Every input in precedence order, decided one included.
+     *
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunOutcomeInputV1 inputs = 2;
+     */
+    inputs: AgentRunOutcomeInputV1[];
+    /**
+     * `agent_run_outcome_v1`. The same discipline `TraceCriticalPathV1.method_code`
+     * applies: a header word computed by an unnamed rule is a word nobody can
+     * argue with, and a later change of rule should be a fixture diff a reviewer
+     * sees.
+     *
+     * @generated from field: string method_code = 3;
+     */
+    methodCode: string;
+    /**
+     * Set only for `_UNKNOWN`: `conversation_still_open` or
+     * `no_member_span_reports_a_status`. Absent on every other verdict, because a
+     * reason attached to `_SUCCEEDED` invites a reader to treat it as the answer.
+     *
+     * @generated from field: optional string outcome_unknown_reason_code = 4;
+     */
+    outcomeUnknownReasonCode?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunOutcomeAssessmentV1.
+ * Use `create(AgentRunOutcomeAssessmentV1Schema)` to create a new message.
+ */
+export declare const AgentRunOutcomeAssessmentV1Schema: GenMessage<AgentRunOutcomeAssessmentV1>;
+/**
+ * One line of the run's spend.
+ *
+ * THERE IS NO RUN-LEVEL MONEY TOTAL ANYWHERE ON THIS SURFACE, and its absence is
+ * the design. A run-wide figure is a bill-shaped object, and a bill-shaped object
+ * on a telemetry read model is how a display-plane estimate ends up quoted at
+ * somebody. `PLAN:1683` says "cost line ITEMS"; a client that wants a total adds
+ * these in front of the reader, where the reader can see what is being added and
+ * that some of it is estimated.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunCostLineItemV1
+ */
+export type AgentRunCostLineItemV1 = Message<"o11y_one.agentic.v1.AgentRunCostLineItemV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceOperationKindV1 kind = 1;
+     */
+    kind: TraceOperationKindV1;
+    /**
+     * The same second key `TraceOperationGroupV1` uses — model id for an LLM line,
+     * tool name for a tool line — so a reader who has learned the vocabulary on the
+     * trace surface does not learn a second one here.
+     *
+     * @generated from field: string target = 2;
+     */
+    target: string;
+    /**
+     * @generated from field: uint32 span_count = 3;
+     */
+    spanCount: number;
+    /**
+     * The trace surface's own rollup, over this bucket's members. Same arithmetic,
+     * a third mount point.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceSpanCostRollupV1 rollup = 4;
+     */
+    rollup?: TraceSpanCostRollupV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunCostLineItemV1.
+ * Use `create(AgentRunCostLineItemV1Schema)` to create a new message.
+ */
+export declare const AgentRunCostLineItemV1Schema: GenMessage<AgentRunCostLineItemV1>;
+/**
+ * The run's token totals, with the accounting basis attached.
+ *
+ * Every field is optional and an absent field is NOT a zero: a provider that
+ * never reported a cache dimension and a provider whose cache never hit must not
+ * arrive as the same number.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunUsageTotalsV1
+ */
+export type AgentRunUsageTotalsV1 = Message<"o11y_one.agentic.v1.AgentRunUsageTotalsV1"> & {
+    /**
+     * @generated from field: optional int64 input_tokens = 1;
+     */
+    inputTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 output_tokens = 2;
+     */
+    outputTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 total_tokens = 3;
+     */
+    totalTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 cache_read_input_tokens = 4;
+     */
+    cacheReadInputTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 cache_creation_input_tokens = 5;
+     */
+    cacheCreationInputTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 reasoning_tokens = 6;
+     */
+    reasoningTokens?: bigint | undefined;
+    /**
+     * How many member spans contributed. Zero means the totals are absent, not
+     * that the run used no tokens.
+     *
+     * @generated from field: uint32 contributing_span_count = 7;
+     */
+    contributingSpanCount: number;
+    /**
+     * NOT_OBSERVED / `no_member_span_carries_token_usage` when nothing contributed.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 8;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+    /**
+     * `provider_accounting_unknown` — the span plane's basis, restated here
+     * because a SUM of six columns is only honest with its basis beside it.
+     *
+     * @generated from field: o11y_one.agentic.v1.EvaluationTokenAccountingV1 token_accounting = 9;
+     */
+    tokenAccounting?: EvaluationTokenAccountingV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunUsageTotalsV1.
+ * Use `create(AgentRunUsageTotalsV1Schema)` to create a new message.
+ */
+export declare const AgentRunUsageTotalsV1Schema: GenMessage<AgentRunUsageTotalsV1>;
+/**
+ * What the score planes say about this run.
+ *
+ * Counts and a worst verdict, never rows: the rows live on the eval and workflow
+ * planes and are reached by a pivot. A summary that embedded them would be a
+ * page in a `SUMMARY`'s clothing (`A2` §2.1 rule 1).
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunScorePostureV1
+ */
+export type AgentRunScorePostureV1 = Message<"o11y_one.agentic.v1.AgentRunScorePostureV1"> & {
+    /**
+     * `eval_scores` rows anchored to a member trace.
+     *
+     * @generated from field: uint32 score_count = 1;
+     */
+    scoreCount: number;
+    /**
+     * @generated from field: uint32 scored_member_trace_count = 2;
+     */
+    scoredMemberTraceCount: number;
+    /**
+     * @generated from field: optional double worst_score_value = 3;
+     */
+    worstScoreValue?: number | undefined;
+    /**
+     * Production-rule verdicts over this run's member traces (wave 39).
+     *
+     * @generated from field: uint32 failing_rule_verdict_count = 4;
+     */
+    failingRuleVerdictCount: number;
+    /**
+     * @generated from field: uint32 passing_rule_verdict_count = 5;
+     */
+    passingRuleVerdictCount: number;
+    /**
+     * A scorer that could not produce a verdict. NEVER counted as a failing
+     * verdict: a scorer that crashed has not judged the run.
+     *
+     * @generated from field: uint32 rule_scorer_failure_count = 6;
+     */
+    ruleScorerFailureCount: number;
+    /**
+     * NOT_OBSERVED / `no_score_plane_row_for_any_member_trace` when both planes are
+     * silent. Silence is not a pass.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 7;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunScorePostureV1.
+ * Use `create(AgentRunScorePostureV1Schema)` to create a new message.
+ */
+export declare const AgentRunScorePostureV1Schema: GenMessage<AgentRunScorePostureV1>;
+/**
+ * The dimensions `PLAN:1683` names and `PLAN:1685` filters on.
+ *
+ * `distinct_count > 1` is not an error — a conversation can legitimately cross
+ * deployments — but it is a fact the reader must be able to see, so the count
+ * rides the value instead of one member silently winning.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunDimensionV1
+ */
+export type AgentRunDimensionV1 = Message<"o11y_one.agentic.v1.AgentRunDimensionV1"> & {
+    /**
+     * @generated from field: optional string value = 1;
+     */
+    value?: string | undefined;
+    /**
+     * @generated from field: uint32 distinct_count = 2;
+     */
+    distinctCount: number;
+    /**
+     * Two different absences, and a reader acts on them differently:
+     * `span_plane_presents_no_run_dimension_columns` is an instrumentation
+     * question for us, `no_member_span_states_this_dimension` is one for them.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 3;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunDimensionV1.
+ * Use `create(AgentRunDimensionV1Schema)` to create a new message.
+ */
+export declare const AgentRunDimensionV1Schema: GenMessage<AgentRunDimensionV1>;
+/**
+ * `PLAN:1683`'s "prompt/model/tool/retrieval versions".
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunVersionContextV1
+ */
+export type AgentRunVersionContextV1 = Message<"o11y_one.agentic.v1.AgentRunVersionContextV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunDimensionV1 prompt_version = 1;
+     */
+    promptVersion?: AgentRunDimensionV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunDimensionV1 model_version = 2;
+     */
+    modelVersion?: AgentRunDimensionV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunDimensionV1 tool_version = 3;
+     */
+    toolVersion?: AgentRunDimensionV1 | undefined;
+    /**
+     * ALWAYS NOT_SUPPORTED / `no_retrieval_version_attribute_in_build`. There is no
+     * retrieval-version attribute anywhere in this build; `o11y.prompt.version` and
+     * `o11y.tool.version` exist and are folded. A version filled from the
+     * nearest-looking attribute would be a version nobody stated.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 retrieval_version_availability = 4;
+     */
+    retrievalVersionAvailability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunVersionContextV1.
+ * Use `create(AgentRunVersionContextV1Schema)` to create a new message.
+ */
+export declare const AgentRunVersionContextV1Schema: GenMessage<AgentRunVersionContextV1>;
+/**
+ * `PLAN:1683`'s "release context".
+ *
+ * The link is transitive and the response says so rather than implying a
+ * relation the planes do not carry: a release names a `release_key`, a release
+ * BLOCK names the same key and an execution, and an execution names a trace.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunReleaseContextV1
+ */
+export type AgentRunReleaseContextV1 = Message<"o11y_one.agentic.v1.AgentRunReleaseContextV1"> & {
+    /**
+     * Release keys reached from this run's member traces, bounded.
+     *
+     * @generated from field: repeated string release_keys = 1;
+     */
+    releaseKeys: string[];
+    /**
+     * @generated from field: uint32 release_count = 2;
+     */
+    releaseCount: number;
+    /**
+     * Blocks in `active` or `indeterminate` over those keys.
+     *
+     * @generated from field: uint32 active_release_block_count = 3;
+     */
+    activeReleaseBlockCount: number;
+    /**
+     * NOT_OBSERVED / `no_release_plane_row_for_any_member_trace` when nothing links.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 4;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunReleaseContextV1.
+ * Use `create(AgentRunReleaseContextV1Schema)` to create a new message.
+ */
+export declare const AgentRunReleaseContextV1Schema: GenMessage<AgentRunReleaseContextV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.AgentRunCoverageReferenceV1
+ */
+export type AgentRunCoverageReferenceV1 = Message<"o11y_one.agentic.v1.AgentRunCoverageReferenceV1"> & {
+    /**
+     * `dataset_item`, `dataset_proposed_case`, `evaluation_run`.
+     *
+     * @generated from field: string reference_kind = 1;
+     */
+    referenceKind: string;
+    /**
+     * @generated from field: string reference_id = 2;
+     */
+    referenceId: string;
+    /**
+     * The member trace that produced the link, so a reader can see WHICH part of
+     * the run is covered rather than only that some of it is.
+     *
+     * @generated from field: optional string member_trace_id = 3;
+     */
+    memberTraceId?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunCoverageReferenceV1.
+ * Use `create(AgentRunCoverageReferenceV1Schema)` to create a new message.
+ */
+export declare const AgentRunCoverageReferenceV1Schema: GenMessage<AgentRunCoverageReferenceV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.AgentRunEvaluationCoverageV1
+ */
+export type AgentRunEvaluationCoverageV1 = Message<"o11y_one.agentic.v1.AgentRunEvaluationCoverageV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunCoverageVerdictV1 verdict = 1;
+     */
+    verdict: AgentRunCoverageVerdictV1;
+    /**
+     * At most `max_coverage_references` (A2 J2.4 states ten). The count is over the
+     * whole population; the list is capped, and `omitted_reference_count` says so.
+     *
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunCoverageReferenceV1 references = 2;
+     */
+    references: AgentRunCoverageReferenceV1[];
+    /**
+     * @generated from field: uint32 covering_reference_count = 3;
+     */
+    coveringReferenceCount: number;
+    /**
+     * @generated from field: uint32 omitted_reference_count = 4;
+     */
+    omittedReferenceCount: number;
+    /**
+     * Set for `_UNKNOWN` only. `provisional_grouping_cannot_claim_lineage` is the
+     * common one and is the `0b P7-10` matrix speaking: a group of unknown
+     * membership has no lineage claim to make, so this build declines to make one
+     * rather than making a weak one.
+     *
+     * @generated from field: optional string unknown_reason_code = 5;
+     */
+    unknownReasonCode?: string | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 6;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunEvaluationCoverageV1.
+ * Use `create(AgentRunEvaluationCoverageV1Schema)` to create a new message.
+ */
+export declare const AgentRunEvaluationCoverageV1Schema: GenMessage<AgentRunEvaluationCoverageV1>;
+/**
+ * `PLAN:1684`'s instrumentation completeness, as facts rather than a grade.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunInstrumentationCompletenessV1
+ */
+export type AgentRunInstrumentationCompletenessV1 = Message<"o11y_one.agentic.v1.AgentRunInstrumentationCompletenessV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.CompletenessStateV1 state = 1;
+     */
+    state: CompletenessStateV1;
+    /**
+     * Member spans attributable to no agent turn. A real gap; never folded into a
+     * neighbouring turn.
+     *
+     * @generated from field: uint32 unattributed_span_count = 2;
+     */
+    unattributedSpanCount: number;
+    /**
+     * Members whose span population exceeded the cap and were refused whole.
+     *
+     * @generated from field: uint32 refused_member_trace_count = 3;
+     */
+    refusedMemberTraceCount: number;
+    /**
+     * `cap + 1` on the worst refused member: AT LEAST this many, never an exact
+     * total. Render it as "10 000+".
+     *
+     * @generated from field: optional uint32 refused_member_observed_span_count = 4;
+     */
+    refusedMemberObservedSpanCount?: number | undefined;
+    /**
+     * Members not read because the run exceeds this build's fold ceiling.
+     *
+     * @generated from field: uint32 unread_member_trace_count = 5;
+     */
+    unreadMemberTraceCount: number;
+    /**
+     * The counters this build cannot produce, each with its reason. They are
+     * NOT_SUPPORTED forever until the build gains the signal, and they are here
+     * rather than as five zeros because a zero handoff count on a run that handed
+     * off is worse than no number at all.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 retry_count_availability = 6;
+     */
+    retryCountAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 handoff_count_availability = 7;
+     */
+    handoffCountAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 guardrail_count_availability = 8;
+     */
+    guardrailCountAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 memory_operation_count_availability = 9;
+     */
+    memoryOperationCountAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * Always NOT_SUPPORTED / `non_streaming_provider_client` — wave 32's code,
+     * reused rather than re-minted.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 time_to_first_token_availability = 10;
+     */
+    timeToFirstTokenAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * Whether every count on the row is a total rather than a lower bound.
+     * AVAILABLE, or NOT_OBSERVED naming the refusal or the ceiling.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 counts_availability = 11;
+     */
+    countsAvailability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunInstrumentationCompletenessV1.
+ * Use `create(AgentRunInstrumentationCompletenessV1Schema)` to create a new message.
+ */
+export declare const AgentRunInstrumentationCompletenessV1Schema: GenMessage<AgentRunInstrumentationCompletenessV1>;
+/**
+ * The `PLAN:1683` field set, served from the maintained projection (`P7-14`).
+ *
+ * EVERY FIELD HERE IS A COLUMN, not a join performed while the page is built.
+ * `PLAN:1687` forbids scanning and hydrating models, tools, scores, releases and
+ * evidence per row, and the way this build keeps that promise is that the read
+ * path holds no query engine and issues no per-row statement — see the
+ * `agent_run_index` capability's `list_span_scans` limit, which is zero.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunSummaryV1
+ */
+export type AgentRunSummaryV1 = Message<"o11y_one.agentic.v1.AgentRunSummaryV1"> & {
+    /**
+     * @generated from field: string agent_run_id = 1;
+     */
+    agentRunId: string;
+    /**
+     * Lane A's spine, carried verbatim: state, confidence, the confidence INPUTS
+     * (`P7-3`), revision, bounds, and the redirect when the id was stale.
+     *
+     * @generated from field: o11y_one.agentic.v1.AgentRunGroupingV1 grouping = 2;
+     */
+    grouping?: AgentRunGroupingV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.ConversationCompletenessV1 completeness = 3;
+     */
+    completeness?: ConversationCompletenessV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunOutcomeAssessmentV1 outcome = 4;
+     */
+    outcome?: AgentRunOutcomeAssessmentV1 | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp started_at = 5;
+     */
+    startedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp ended_at = 6;
+     */
+    endedAt?: Timestamp | undefined;
+    /**
+     * The keyset's sort key. A late span advances it and the run RE-SURFACES at the
+     * head of the list; `P7-16`'s watermark rule is what makes that legible rather
+     * than a reshuffle.
+     *
+     * @generated from field: google.protobuf.Timestamp last_seen_at = 7;
+     */
+    lastSeenAt?: Timestamp | undefined;
+    /**
+     * @generated from field: uint32 trace_count = 8;
+     */
+    traceCount: number;
+    /**
+     * @generated from field: uint32 folded_trace_count = 9;
+     */
+    foldedTraceCount: number;
+    /**
+     * @generated from field: uint32 span_count = 10;
+     */
+    spanCount: number;
+    /**
+     * Σ of the members' own OTel event counts. Absent when the scanned schema did
+     * not present the column.
+     *
+     * @generated from field: optional int64 span_event_count = 11;
+     */
+    spanEventCount?: bigint | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 span_event_count_availability = 12;
+     */
+    spanEventCountAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * @generated from field: uint32 agent_count = 13;
+     */
+    agentCount: number;
+    /**
+     * @generated from field: uint32 model_count = 14;
+     */
+    modelCount: number;
+    /**
+     * @generated from field: uint32 tool_count = 15;
+     */
+    toolCount: number;
+    /**
+     * @generated from field: uint32 retrieval_span_count = 16;
+     */
+    retrievalSpanCount: number;
+    /**
+     * @generated from field: uint32 mcp_span_count = 17;
+     */
+    mcpSpanCount: number;
+    /**
+     * @generated from field: uint32 hard_failure_count = 18;
+     */
+    hardFailureCount: number;
+    /**
+     * Spans that recorded a fault WITHOUT failing. Wave 35 found this is zero by
+     * construction in today's ingest (`classify_error` ORs the exception into
+     * `is_error`); the field is computed correctly and kept, on the same argument
+     * wave 35 gave for keeping `warned_span_count`.
+     *
+     * @generated from field: uint32 degraded_failure_count = 19;
+     */
+    degradedFailureCount: number;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceFaultBreakdownV1 faults = 20;
+     */
+    faults?: TraceFaultBreakdownV1 | undefined;
+    /**
+     * @generated from field: optional o11y_one.agentic.v1.TraceFirstFailureV1 first_failure = 21;
+     */
+    firstFailure?: TraceFirstFailureV1 | undefined;
+    /**
+     * The MAXIMUM of the members' own critical paths, not a new chain definition.
+     *
+     * @generated from field: optional int64 critical_path_latency_micros = 22;
+     */
+    criticalPathLatencyMicros?: bigint | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 critical_path_availability = 23;
+     */
+    criticalPathAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * `latest_finishing_child_chain_v1` — the trace surface's code, because it is
+     * the trace surface's derivation.
+     *
+     * @generated from field: string critical_path_method_code = 24;
+     */
+    criticalPathMethodCode: string;
+    /**
+     * Which member produced it, so the number is followable.
+     *
+     * @generated from field: optional string critical_path_trace_id = 25;
+     */
+    criticalPathTraceId?: string | undefined;
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunCostLineItemV1 cost_line_items = 26;
+     */
+    costLineItems: AgentRunCostLineItemV1[];
+    /**
+     * @generated from field: uint32 omitted_cost_line_item_count = 27;
+     */
+    omittedCostLineItemCount: number;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunUsageTotalsV1 usage = 28;
+     */
+    usage?: AgentRunUsageTotalsV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunScorePostureV1 score_posture = 29;
+     */
+    scorePosture?: AgentRunScorePostureV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunDimensionV1 customer = 30;
+     */
+    customer?: AgentRunDimensionV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunDimensionV1 deployment = 31;
+     */
+    deployment?: AgentRunDimensionV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunVersionContextV1 versions = 32;
+     */
+    versions?: AgentRunVersionContextV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunReleaseContextV1 release_context = 33;
+     */
+    releaseContext?: AgentRunReleaseContextV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunInstrumentationCompletenessV1 instrumentation = 34;
+     */
+    instrumentation?: AgentRunInstrumentationCompletenessV1 | undefined;
+    /**
+     * The projection's own version and the watermark the fold read through.
+     *
+     * @generated from field: uint64 projection_version = 35;
+     */
+    projectionVersion: bigint;
+    /**
+     * @generated from field: optional string facts_watermark = 36;
+     */
+    factsWatermark?: string | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp refreshed_at = 37;
+     */
+    refreshedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.EvaluationFreshnessV1 freshness = 38;
+     */
+    freshness?: EvaluationFreshnessV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunSummaryV1.
+ * Use `create(AgentRunSummaryV1Schema)` to create a new message.
+ */
+export declare const AgentRunSummaryV1Schema: GenMessage<AgentRunSummaryV1>;
+/**
+ * `PLAN:1685` — the filters Production > Agent runs needs.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunListFilterV1
+ */
+export type AgentRunListFilterV1 = Message<"o11y_one.agentic.v1.AgentRunListFilterV1"> & {
+    /**
+     * @generated from field: optional string customer_id = 1;
+     */
+    customerId?: string | undefined;
+    /**
+     * @generated from field: optional string deployment_id = 2;
+     */
+    deploymentId?: string | undefined;
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunOutcomeV1 outcomes = 3;
+     */
+    outcomes: AgentRunOutcomeV1[];
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunGroupingConfidenceV1 grouping_confidences = 4;
+     */
+    groupingConfidences: AgentRunGroupingConfidenceV1[];
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.ConversationCompletenessStateV1 completeness_states = 5;
+     */
+    completenessStates: ConversationCompletenessStateV1[];
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.CompletenessStateV1 instrumentation_states = 6;
+     */
+    instrumentationStates: CompletenessStateV1[];
+    /**
+     * @generated from field: optional string prompt_version = 7;
+     */
+    promptVersion?: string | undefined;
+    /**
+     * @generated from field: optional string model_version = 8;
+     */
+    modelVersion?: string | undefined;
+    /**
+     * @generated from field: optional string tool_version = 9;
+     */
+    toolVersion?: string | undefined;
+    /**
+     * `P7-4`/`B1-4`: identity-less traces appear as single-trace runs and are
+     * INCLUDED by default. Setting this hides them and the response then reports
+     * `hidden_ungrouped_run_count` — R8's rule, satisfied by construction rather
+     * than by a default the caller has to discover.
+     *
+     * @generated from field: bool exclude_ungrouped = 10;
+     */
+    excludeUngrouped: boolean;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunListFilterV1.
+ * Use `create(AgentRunListFilterV1Schema)` to create a new message.
+ */
+export declare const AgentRunListFilterV1Schema: GenMessage<AgentRunListFilterV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.ListAgentRunsRequest
+ */
+export type ListAgentRunsRequest = Message<"o11y_one.agentic.v1.ListAgentRunsRequest"> & {
+    /**
+     * @generated from field: optional google.protobuf.Timestamp start = 1;
+     */
+    start?: Timestamp | undefined;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp end = 2;
+     */
+    end?: Timestamp | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunListFilterV1 filter = 3;
+     */
+    filter?: AgentRunListFilterV1 | undefined;
+    /**
+     * @generated from field: optional uint32 limit = 4;
+     */
+    limit?: number | undefined;
+    /**
+     * Opaque keyset cursor over `(last_seen_at DESC, agent_run_id DESC)`, bound to
+     * a facts watermark. Never an offset.
+     *
+     * @generated from field: optional string page_token = 5;
+     */
+    pageToken?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.ListAgentRunsRequest.
+ * Use `create(ListAgentRunsRequestSchema)` to create a new message.
+ */
+export declare const ListAgentRunsRequestSchema: GenMessage<ListAgentRunsRequest>;
+/**
+ * @generated from message o11y_one.agentic.v1.ListAgentRunsResponse
+ */
+export type ListAgentRunsResponse = Message<"o11y_one.agentic.v1.ListAgentRunsResponse"> & {
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunSummaryV1 runs = 1;
+     */
+    runs: AgentRunSummaryV1[];
+    /**
+     * @generated from field: optional string next_page_token = 2;
+     */
+    nextPageToken?: string | undefined;
+    /**
+     * @generated from field: bool has_more = 3;
+     */
+    hasMore: boolean;
+    /**
+     * How many `_UNGROUPED` runs the filter removed. Present whenever
+     * `exclude_ungrouped` was set, INCLUDING when it is zero: an empty list is
+     * never evidence of none (R8).
+     *
+     * @generated from field: optional uint32 hidden_ungrouped_run_count = 4;
+     */
+    hiddenUngroupedRunCount?: number | undefined;
+    /**
+     * Clamped IN BAND, with the reason. The `ListSessions` silent clamp is the
+     * defect this field exists not to repeat.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceWindowV1 window = 5;
+     */
+    window?: TraceWindowV1 | undefined;
+    /**
+     * The population the projection was built from, declared.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceSpanPopulationBoundaryV1 boundary = 6;
+     */
+    boundary?: TraceSpanPopulationBoundaryV1 | undefined;
+    /**
+     * `keyset_last_seen_desc_late_data_resurfaces_at_head_v1`. Named on the wire
+     * because "stable under late data" means something specific here and a client
+     * that guesses will guess "nothing moves".
+     *
+     * @generated from field: string cursor_semantics_code = 7;
+     */
+    cursorSemanticsCode: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.EvaluationFreshnessV1 freshness = 8;
+     */
+    freshness?: EvaluationFreshnessV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgenticEvaluationCapabilitiesV1 capabilities = 9;
+     */
+    capabilities?: AgenticEvaluationCapabilitiesV1 | undefined;
+    /**
+     * @generated from field: optional o11y_one.agentic.v1.TraceReadRefusalV1 refusal = 10;
+     */
+    refusal?: TraceReadRefusalV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.ListAgentRunsResponse.
+ * Use `create(ListAgentRunsResponseSchema)` to create a new message.
+ */
+export declare const ListAgentRunsResponseSchema: GenMessage<ListAgentRunsResponse>;
+/**
+ * @generated from message o11y_one.agentic.v1.GetAgentRunRequest
+ */
+export type GetAgentRunRequest = Message<"o11y_one.agentic.v1.GetAgentRunRequest"> & {
+    /**
+     * A stale (`_MERGED_AWAY` / `_SPLIT_AWAY` / `_REDIRECTED`) id is answered with
+     * the canonical run plus `summary.grouping.redirect`, never `NOT_FOUND`
+     * (`P7-6`). A run in another tenant IS `NOT_FOUND`, and the two are different
+     * answers on purpose.
+     *
+     * @generated from field: string agent_run_id = 1;
+     */
+    agentRunId: string;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.GetAgentRunRequest.
+ * Use `create(GetAgentRunRequestSchema)` to create a new message.
+ */
+export declare const GetAgentRunRequestSchema: GenMessage<GetAgentRunRequest>;
+/**
+ * @generated from message o11y_one.agentic.v1.GetAgentRunResponse
+ */
+export type GetAgentRunResponse = Message<"o11y_one.agentic.v1.GetAgentRunResponse"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunSummaryV1 summary = 1;
+     */
+    summary?: AgentRunSummaryV1 | undefined;
+    /**
+     * J2 step 7. On the DETAIL only — putting it on every list row would be the
+     * per-row hydration `PLAN:1687` forbids, even though the value is a stored
+     * column, because the payload would then grow with the page.
+     *
+     * @generated from field: o11y_one.agentic.v1.AgentRunEvaluationCoverageV1 evaluation_coverage = 2;
+     */
+    evaluationCoverage?: AgentRunEvaluationCoverageV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceWindowV1 window = 3;
+     */
+    window?: TraceWindowV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceSpanPopulationBoundaryV1 boundary = 4;
+     */
+    boundary?: TraceSpanPopulationBoundaryV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.EvaluationFreshnessV1 freshness = 5;
+     */
+    freshness?: EvaluationFreshnessV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgenticEvaluationCapabilitiesV1 capabilities = 6;
+     */
+    capabilities?: AgenticEvaluationCapabilitiesV1 | undefined;
+    /**
+     * @generated from field: optional o11y_one.agentic.v1.TraceReadRefusalV1 refusal = 7;
+     */
+    refusal?: TraceReadRefusalV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.GetAgentRunResponse.
+ * Use `create(GetAgentRunResponseSchema)` to create a new message.
+ */
+export declare const GetAgentRunResponseSchema: GenMessage<GetAgentRunResponse>;
+/**
+ * Which of `PLAN:1691`'s event families this build can actually produce.
+ *
+ * `kind` is a slug rather than `AgentRunEventKindV1` deliberately: the four
+ * families with no ingest source have no enum arm, and giving them one so they
+ * could be reported absent would be minting the very kinds this lane refuses to
+ * invent.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunEventKindCoverageV1
+ */
+export type AgentRunEventKindCoverageV1 = Message<"o11y_one.agentic.v1.AgentRunEventKindCoverageV1"> & {
+    /**
+     * `model` | `tool` | `retrieval` | `downstream` | `error` | `generic` |
+     * `handoff` | `memory` | `guardrail` | `retry`.
+     *
+     * @generated from field: string kind = 1;
+     */
+    kind: string;
+    /**
+     * AVAILABLE for the six; NOT_SUPPORTED with `no_handoff_attribute_ingested`,
+     * `no_memory_attribute_ingested`, `no_guardrail_attribute_ingested` or
+     * `span_plane_marks_no_retry_relationship` for the four.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 2;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunEventKindCoverageV1.
+ * Use `create(AgentRunEventKindCoverageV1Schema)` to create a new message.
+ */
+export declare const AgentRunEventKindCoverageV1Schema: GenMessage<AgentRunEventKindCoverageV1>;
+/**
+ * Which of `AL-1`'s five source kinds this build can actually receive a link
+ * from.
+ *
+ * This is how a client tells "this run has no artifacts" from "this build could
+ * not have seen one" — NN11's rule that a refusal is observable, applied to an
+ * absence.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunArtifactSourceCoverageV1
+ */
+export type AgentRunArtifactSourceCoverageV1 = Message<"o11y_one.agentic.v1.AgentRunArtifactSourceCoverageV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.ArtifactLinkSourceKindV1 source_kind = 1;
+     */
+    sourceKind: ArtifactLinkSourceKindV1;
+    /**
+     * AVAILABLE for `FALLBACK_RPC` and `BACKFILL`. NOT_SUPPORTED with
+     * `span_event_path_not_ingested`, `span_attribute_path_not_projected` or
+     * `correlated_log_path_not_shipped` for the three telemetry paths, none of
+     * which has an ingest path in this build.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 2;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunArtifactSourceCoverageV1.
+ * Use `create(AgentRunArtifactSourceCoverageV1Schema)` to create a new message.
+ */
+export declare const AgentRunArtifactSourceCoverageV1Schema: GenMessage<AgentRunArtifactSourceCoverageV1>;
+/**
+ * The deprecated-alias provenance channel (`PLAN:1695`).
+ *
+ * This is the ONLY place a legacy `o11y.*` string reaches a response. The public
+ * typed field is the neutral one — semconv registry §4.4 establishes that the
+ * response surface is already neutral, and this lane does not breach it.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunEventAttributeProvenanceV1
+ */
+export type AgentRunEventAttributeProvenanceV1 = Message<"o11y_one.agentic.v1.AgentRunEventAttributeProvenanceV1"> & {
+    /**
+     * The public, neutral field this resolves to.
+     *
+     * @generated from field: string canonical_field = 1;
+     */
+    canonicalField: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunAttributeSourceV1 source = 2;
+     */
+    source: AgentRunAttributeSourceV1;
+    /**
+     * The deprecated spelling that contributed. Absent when none did.
+     *
+     * @generated from field: optional string legacy_name = 3;
+     */
+    legacyName?: string | undefined;
+    /**
+     * Set only on `_CONFLICT`: the value canonical precedence discarded, kept so
+     * the disagreement is readable rather than merely counted.
+     *
+     * @generated from field: optional string discarded_legacy_value = 4;
+     */
+    discardedLegacyValue?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunEventAttributeProvenanceV1.
+ * Use `create(AgentRunEventAttributeProvenanceV1Schema)` to create a new message.
+ */
+export declare const AgentRunEventAttributeProvenanceV1Schema: GenMessage<AgentRunEventAttributeProvenanceV1>;
+/**
+ * Per-event token usage, compact.
+ *
+ * The arithmetic is `span_usage`'s — the same six `gen_ai.usage.*` columns the
+ * trace surface reads — projected to six integers rather than carried as a full
+ * `ProviderUsageRecordV1`. Two hundred verbatim records would spend the page's
+ * byte budget on a field a timeline row does not need; the VERBATIM record stays
+ * available on `ListAgentTraceSpans`, which is the surface for it.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunEventUsageV1
+ */
+export type AgentRunEventUsageV1 = Message<"o11y_one.agentic.v1.AgentRunEventUsageV1"> & {
+    /**
+     * @generated from field: optional int64 input_tokens = 1;
+     */
+    inputTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 output_tokens = 2;
+     */
+    outputTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 total_tokens = 3;
+     */
+    totalTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 cache_read_input_tokens = 4;
+     */
+    cacheReadInputTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 cache_creation_input_tokens = 5;
+     */
+    cacheCreationInputTokens?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 reasoning_tokens = 6;
+     */
+    reasoningTokens?: bigint | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 7;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunEventUsageV1.
+ * Use `create(AgentRunEventUsageV1Schema)` to create a new message.
+ */
+export declare const AgentRunEventUsageV1Schema: GenMessage<AgentRunEventUsageV1>;
+/**
+ * Generation settings and response identity, "where applicable" (`PLAN:1694`).
+ *
+ * Every field optional, because most spans are not model calls and a zero would
+ * claim a temperature nobody set.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunEventGenerationV1
+ */
+export type AgentRunEventGenerationV1 = Message<"o11y_one.agentic.v1.AgentRunEventGenerationV1"> & {
+    /**
+     * @generated from field: optional string request_model = 1;
+     */
+    requestModel?: string | undefined;
+    /**
+     * @generated from field: optional string response_model = 2;
+     */
+    responseModel?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunEventGenerationV1.
+ * Use `create(AgentRunEventGenerationV1Schema)` to create a new message.
+ */
+export declare const AgentRunEventGenerationV1Schema: GenMessage<AgentRunEventGenerationV1>;
+/**
+ * One lane of the timeline (`PLAN:1694`, `BP:756-766`).
+ *
+ * Discovered from `gen_ai.agent.id` / `gen_ai.agent.name` / `service.name` at
+ * render time, never a fixed vocabulary: handoff doc 11 §8.1 records the
+ * prototype's four-value lane TYPE as the specific trap here. Work with no agent
+ * identity gets the `unattributed` lane rather than being dropped, so the lane
+ * counts and the event count agree.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunLaneV1
+ */
+export type AgentRunLaneV1 = Message<"o11y_one.agentic.v1.AgentRunLaneV1"> & {
+    /**
+     * @generated from field: string lane_id = 1;
+     */
+    laneId: string;
+    /**
+     * @generated from field: optional string display_name = 2;
+     */
+    displayName?: string | undefined;
+    /**
+     * @generated from field: uint32 event_count = 3;
+     */
+    eventCount: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunLaneV1.
+ * Use `create(AgentRunLaneV1Schema)` to create a new message.
+ */
+export declare const AgentRunLaneV1Schema: GenMessage<AgentRunLaneV1>;
+/**
+ * A nested child of an event, summarised. Capped independently.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunChildSummaryV1
+ */
+export type AgentRunChildSummaryV1 = Message<"o11y_one.agentic.v1.AgentRunChildSummaryV1"> & {
+    /**
+     * @generated from field: string event_id = 1;
+     */
+    eventId: string;
+    /**
+     * @generated from field: string name = 2;
+     */
+    name: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunEventKindV1 kind = 3;
+     */
+    kind: AgentRunEventKindV1;
+    /**
+     * @generated from field: int64 duration_micros = 4;
+     */
+    durationMicros: bigint;
+    /**
+     * @generated from field: bool is_error = 5;
+     */
+    isError: boolean;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunChildSummaryV1.
+ * Use `create(AgentRunChildSummaryV1Schema)` to create a new message.
+ */
+export declare const AgentRunChildSummaryV1Schema: GenMessage<AgentRunChildSummaryV1>;
+/**
+ * An artifact linked to this event, SUMMARISED (`PLAN:1703`).
+ *
+ * A summary, never content: `PLAN:1700` keeps large payloads behind the existing
+ * artifact content APIs, and `AL-14` rule 1 forbids resolving anything while
+ * building a page. `resolver_posture` is what the timeline shows instead — a
+ * client can render "resolvable" without a single byte having been fetched.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunArtifactSummaryV1
+ */
+export type AgentRunArtifactSummaryV1 = Message<"o11y_one.agentic.v1.AgentRunArtifactSummaryV1"> & {
+    /**
+     * @generated from field: bytes link_id = 1;
+     */
+    linkId: Uint8Array;
+    /**
+     * @generated from field: string artifact_id = 2;
+     */
+    artifactId: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.ArtifactTypeV1 artifact_type = 3;
+     */
+    artifactType: ArtifactTypeV1;
+    /**
+     * @generated from field: o11y_one.agentic.v1.ArtifactRoleV1 role = 4;
+     */
+    role: ArtifactRoleV1;
+    /**
+     * @generated from field: o11y_one.agentic.v1.ArtifactRelationV1 relation = 5;
+     */
+    relation: ArtifactRelationV1;
+    /**
+     * The CURRENT status: the row's write-time status overlaid with the
+     * append-only correction ledger. A revoked link is projected identically to an
+     * accepted one apart from this field and its audit — `PLAN:1693`.
+     *
+     * @generated from field: o11y_one.agentic.v1.ArtifactLinkStatusV1 status = 6;
+     */
+    status: ArtifactLinkStatusV1;
+    /**
+     * @generated from field: o11y_one.agentic.v1.ArtifactLinkConflictPostureV1 conflict_posture = 7;
+     */
+    conflictPosture: ArtifactLinkConflictPostureV1;
+    /**
+     * `SM-13`. Posture, never resolution.
+     *
+     * @generated from field: o11y_one.agentic.v1.ArtifactResolverPostureV1 resolver_posture = 8;
+     */
+    resolverPosture: ArtifactResolverPostureV1;
+    /**
+     * `AL-1`: the ONLY thing that distinguishes the paths. The typed read model is
+     * otherwise identical, which is exit `:1733`'s whole claim.
+     *
+     * @generated from field: o11y_one.agentic.v1.ArtifactLinkSourceKindV1 source_kind = 9;
+     */
+    sourceKind: ArtifactLinkSourceKindV1;
+    /**
+     * @generated from field: optional o11y_one.agentic.v1.ArtifactLinkFallbackReasonV1 fallback_reason = 10;
+     */
+    fallbackReason?: ArtifactLinkFallbackReasonV1 | undefined;
+    /**
+     * @generated from field: optional string media_type = 11;
+     */
+    mediaType?: string | undefined;
+    /**
+     * @generated from field: optional string filename = 12;
+     */
+    filename?: string | undefined;
+    /**
+     * @generated from field: optional string storage_system = 13;
+     */
+    storageSystem?: string | undefined;
+    /**
+     * @generated from field: optional string resolver_key = 14;
+     */
+    resolverKey?: string | undefined;
+    /**
+     * @generated from field: uint32 correction_sequence = 15;
+     */
+    correctionSequence: number;
+    /**
+     * `normalize::ArtifactLinkRejectionReason::as_str()`. Machine-groupable,
+     * never prose — `PLAN:1692` requires rejected/unresolved diagnostics to be
+     * preserved "without requiring raw-key parsing in the timeline".
+     *
+     * @generated from field: optional string rejection_reason_code = 16;
+     */
+    rejectionReasonCode?: string | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp observed_at = 17;
+     */
+    observedAt?: Timestamp | undefined;
+    /**
+     * The anchor the link was made against, reusing the locked twelve-arm shape.
+     *
+     * @generated from field: o11y_one.agentic.v1.EvidenceAnchorV1 anchor = 18;
+     */
+    anchor?: EvidenceAnchorV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunArtifactSummaryV1.
+ * Use `create(AgentRunArtifactSummaryV1Schema)` to create a new message.
+ */
+export declare const AgentRunArtifactSummaryV1Schema: GenMessage<AgentRunArtifactSummaryV1>;
+/**
+ * A link that did not become a usable artifact summary, and why.
+ *
+ * Grouped by reason code rather than listed per link, so a run with a thousand
+ * malformed emissions costs the page a handful of rows instead of a thousand.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunArtifactDiagnosticV1
+ */
+export type AgentRunArtifactDiagnosticV1 = Message<"o11y_one.agentic.v1.AgentRunArtifactDiagnosticV1"> & {
+    /**
+     * @generated from field: string reason_code = 1;
+     */
+    reasonCode: string;
+    /**
+     * @generated from field: uint32 occurrence_count = 2;
+     */
+    occurrenceCount: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunArtifactDiagnosticV1.
+ * Use `create(AgentRunArtifactDiagnosticV1Schema)` to create a new message.
+ */
+export declare const AgentRunArtifactDiagnosticV1Schema: GenMessage<AgentRunArtifactDiagnosticV1>;
+/**
+ * What each nested family lost to its own cap (`PLAN:1698`).
+ *
+ * Per family, because the caps are INDEPENDENT: an event with six artifacts and
+ * one child loses one artifact and no child. A single shared cap would make one
+ * noisy family silence another.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunNestedCapsV1
+ */
+export type AgentRunNestedCapsV1 = Message<"o11y_one.agentic.v1.AgentRunNestedCapsV1"> & {
+    /**
+     * @generated from field: uint32 children_omitted = 1;
+     */
+    childrenOmitted: number;
+    /**
+     * @generated from field: uint32 artifacts_omitted = 2;
+     */
+    artifactsOmitted: number;
+    /**
+     * @generated from field: uint32 content_refs_omitted = 3;
+     */
+    contentRefsOmitted: number;
+    /**
+     * @generated from field: uint32 attribute_provenance_omitted = 4;
+     */
+    attributeProvenanceOmitted: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunNestedCapsV1.
+ * Use `create(AgentRunNestedCapsV1Schema)` to create a new message.
+ */
+export declare const AgentRunNestedCapsV1Schema: GenMessage<AgentRunNestedCapsV1>;
+/**
+ * One timeline event (`PLAN:1694`).
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunEventV1
+ */
+export type AgentRunEventV1 = Message<"o11y_one.agentic.v1.AgentRunEventV1"> & {
+    /**
+     * `trace_id:span_id`. Stable across re-reads, unique across the run's member
+     * traces, and the key `P7-16`'s upserts are applied by.
+     *
+     * @generated from field: string event_id = 1;
+     */
+    eventId: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunEventDeliveryV1 delivery = 2;
+     */
+    delivery: AgentRunEventDeliveryV1;
+    /**
+     * @generated from field: string lane_id = 3;
+     */
+    laneId: string;
+    /**
+     * @generated from field: optional string agent_name = 4;
+     */
+    agentName?: string | undefined;
+    /**
+     * @generated from field: optional string agent_id = 5;
+     */
+    agentId?: string | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunEventKindV1 kind = 6;
+     */
+    kind: AgentRunEventKindV1;
+    /**
+     * The trace viewer's own operation kind, carried so a client can render the
+     * same icon on both surfaces.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceOperationKindV1 operation_kind = 7;
+     */
+    operationKind: TraceOperationKindV1;
+    /**
+     * The most specific identifier the event carries for its kind: tool name,
+     * model id, route, data source. Never empty.
+     *
+     * @generated from field: string subject = 8;
+     */
+    subject: string;
+    /**
+     * @generated from field: string name = 9;
+     */
+    name: string;
+    /**
+     * @generated from field: string trace_id = 10;
+     */
+    traceId: string;
+    /**
+     * @generated from field: string span_id = 11;
+     */
+    spanId: string;
+    /**
+     * @generated from field: optional string parent_span_id = 12;
+     */
+    parentSpanId?: string | undefined;
+    /**
+     * The parent's `event_id`, when the parent is inside this run's population.
+     * Absent when the parent started before the window — an honest absence rather
+     * than a dangling reference.
+     *
+     * @generated from field: optional string parent_event_id = 13;
+     */
+    parentEventId?: string | undefined;
+    /**
+     * @generated from field: optional string step_id = 14;
+     */
+    stepId?: string | undefined;
+    /**
+     * From the RUN, not from the span: the span reader does not project
+     * `gen_ai.conversation.id` today.
+     *
+     * @generated from field: optional string conversation_id = 15;
+     */
+    conversationId?: string | undefined;
+    /**
+     * NOT_SUPPORTED with `observation_id_not_projected_by_span_reader` until the
+     * span projection carries `o11y.observation.id`. An availability, never an
+     * empty string.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 observation_id_availability = 16;
+     */
+    observationIdAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * @generated from field: optional string observation_id = 17;
+     */
+    observationId?: string | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp started_at = 18;
+     */
+    startedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp ended_at = 19;
+     */
+    endedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: int64 duration_micros = 20;
+     */
+    durationMicros: bigint;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceSpanStatusV1 status = 21;
+     */
+    status: TraceSpanStatusV1;
+    /**
+     * @generated from field: bool is_error = 22;
+     */
+    isError: boolean;
+    /**
+     * @generated from field: bool has_exception_event = 23;
+     */
+    hasExceptionEvent: boolean;
+    /**
+     * @generated from field: optional o11y_one.agentic.v1.TraceFaultCategoryV1 fault_category = 24;
+     */
+    faultCategory?: TraceFaultCategoryV1 | undefined;
+    /**
+     * @generated from field: optional string error_type = 25;
+     */
+    errorType?: string | undefined;
+    /**
+     * @generated from field: optional string error_message = 26;
+     */
+    errorMessage?: string | undefined;
+    /**
+     * @generated from field: bool on_critical_path = 27;
+     */
+    onCriticalPath: boolean;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunEventGenerationV1 generation = 28;
+     */
+    generation?: AgentRunEventGenerationV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunEventUsageV1 usage = 29;
+     */
+    usage?: AgentRunEventUsageV1 | undefined;
+    /**
+     * `span_cost::span_cost`, by import. A list-rate estimate with its provenance
+     * attached, never a bill.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceSpanCostV1 cost = 30;
+     */
+    cost?: TraceSpanCostV1 | undefined;
+    /**
+     * References, never bodies (`PLAN:1700`). The `reasoning` class is a
+     * provider-exposed SUMMARY reference and nothing else (NN27).
+     *
+     * @generated from field: repeated o11y_one.agentic.v1.TraceSpanContentRefV1 content_refs = 31;
+     */
+    contentRefs: TraceSpanContentRefV1[];
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunEventAttributeProvenanceV1 attribute_provenance = 32;
+     */
+    attributeProvenance: AgentRunEventAttributeProvenanceV1[];
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunChildSummaryV1 children = 33;
+     */
+    children: AgentRunChildSummaryV1[];
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunArtifactSummaryV1 artifacts = 34;
+     */
+    artifacts: AgentRunArtifactSummaryV1[];
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunNestedCapsV1 nested_caps = 35;
+     */
+    nestedCaps?: AgentRunNestedCapsV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunEventV1.
+ * Use `create(AgentRunEventV1Schema)` to create a new message.
+ */
+export declare const AgentRunEventV1Schema: GenMessage<AgentRunEventV1>;
+/**
+ * Whether the server actually filtered, and by how much (`PLAN:1696`).
+ *
+ * `0b P7-15`: server-side filters exist "only where they materially reduce
+ * payload — a filter that returns 195 of 200 events is a client concern". The
+ * rule is published as a number (`filter_materiality_retained_percent`) and the
+ * verdict is on the wire, because a client that had to GUESS whether the server
+ * filtered would filter defensively every time and the server's filter would buy
+ * nothing.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunTimelineModeEffectV1
+ */
+export type AgentRunTimelineModeEffectV1 = Message<"o11y_one.agentic.v1.AgentRunTimelineModeEffectV1"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunTimelineModeV1 mode = 1;
+     */
+    mode: AgentRunTimelineModeV1;
+    /**
+     * @generated from field: bool applied = 2;
+     */
+    applied: boolean;
+    /**
+     * `mode_is_unfiltered` | `filter_not_material` |
+     * `filter_materially_reduces_payload`.
+     *
+     * @generated from field: string reason_code = 3;
+     */
+    reasonCode: string;
+    /**
+     * @generated from field: uint32 population_count = 4;
+     */
+    populationCount: number;
+    /**
+     * What the mode keeps. Reported whether or not it was applied, so a client can
+     * check the rule rather than trust it.
+     *
+     * @generated from field: uint32 retained_count = 5;
+     */
+    retainedCount: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunTimelineModeEffectV1.
+ * Use `create(AgentRunTimelineModeEffectV1Schema)` to create a new message.
+ */
+export declare const AgentRunTimelineModeEffectV1Schema: GenMessage<AgentRunTimelineModeEffectV1>;
+/**
+ * `0b P7-16`'s cursor.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunTimelineCursorV1
+ */
+export type AgentRunTimelineCursorV1 = Message<"o11y_one.agentic.v1.AgentRunTimelineCursorV1"> & {
+    /**
+     * Absent when the page exhausted the population.
+     *
+     * @generated from field: optional string next_page_token = 1;
+     */
+    nextPageToken?: string | undefined;
+    /**
+     * The prefix to re-emit was larger than this build re-emits, so the client
+     * restarts from page 1. A typed escape, never a silent truncation.
+     *
+     * @generated from field: bool resync_required = 2;
+     */
+    resyncRequired: boolean;
+    /**
+     * Lane A's monotone projection version this page was built at.
+     *
+     * @generated from field: int64 projection_version = 3;
+     */
+    projectionVersion: bigint;
+    /**
+     * Set when the BYTE ceiling ended the page rather than the event count.
+     * "200 events" and "as many as fit" are different answers and an operator
+     * diagnosing a short page needs to know which one they got.
+     *
+     * @generated from field: bool stopped_on_byte_ceiling = 4;
+     */
+    stoppedOnByteCeiling: boolean;
+    /**
+     * How many events this cursor walks in total, AFTER the mode decision. The
+     * denominator a client needs to know how many pages to expect — without it,
+     * "is there more?" is answerable only by asking for more.
+     *
+     * @generated from field: uint32 total_event_count = 5;
+     */
+    totalEventCount: number;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunTimelineCursorV1.
+ * Use `create(AgentRunTimelineCursorV1Schema)` to create a new message.
+ */
+export declare const AgentRunTimelineCursorV1Schema: GenMessage<AgentRunTimelineCursorV1>;
+/**
+ * The cost-driving event of the run (J2 step 4).
+ *
+ * The single largest AVAILABLE per-event cost — not a sum. A sum would be the
+ * run-level money total handoff doc 11 §8 refuses to publish.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentRunTimelineCostDriverV1
+ */
+export type AgentRunTimelineCostDriverV1 = Message<"o11y_one.agentic.v1.AgentRunTimelineCostDriverV1"> & {
+    /**
+     * @generated from field: optional string event_id = 1;
+     */
+    eventId?: string | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceSpanCostV1 cost = 2;
+     */
+    cost?: TraceSpanCostV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 availability = 3;
+     */
+    availability?: MetricAvailabilityV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentRunTimelineCostDriverV1.
+ * Use `create(AgentRunTimelineCostDriverV1Schema)` to create a new message.
+ */
+export declare const AgentRunTimelineCostDriverV1Schema: GenMessage<AgentRunTimelineCostDriverV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.ListAgentRunEventsRequest
+ */
+export type ListAgentRunEventsRequest = Message<"o11y_one.agentic.v1.ListAgentRunEventsRequest"> & {
+    /**
+     * A non-`_CURRENT` id is not an error: it resolves to the canonical run and
+     * the response carries the redirect (`P7-6`).
+     *
+     * @generated from field: string agent_run_id = 1;
+     */
+    agentRunId: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunTimelineModeV1 mode = 2;
+     */
+    mode: AgentRunTimelineModeV1;
+    /**
+     * From a previous response. Bound to the run, the mode and the projection
+     * version it was minted at; replayed against a different run or mode it is
+     * refused rather than silently re-pointed.
+     *
+     * @generated from field: optional string page_token = 3;
+     */
+    pageToken?: string | undefined;
+    /**
+     * Clamped to the published maximum rather than refused, so a client that asks
+     * for more gets the maximum and the capability tells it what that is.
+     *
+     * @generated from field: optional uint32 page_size = 4;
+     */
+    pageSize?: number | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.ListAgentRunEventsRequest.
+ * Use `create(ListAgentRunEventsRequestSchema)` to create a new message.
+ */
+export declare const ListAgentRunEventsRequestSchema: GenMessage<ListAgentRunEventsRequest>;
+/**
+ * @generated from message o11y_one.agentic.v1.ListAgentRunEventsResponse
+ */
+export type ListAgentRunEventsResponse = Message<"o11y_one.agentic.v1.ListAgentRunEventsResponse"> & {
+    /**
+     * The CANONICAL run id, which may differ from the one requested.
+     *
+     * @generated from field: string agent_run_id = 1;
+     */
+    agentRunId: string;
+    /**
+     * Present when the requested id was not `_CURRENT` (`P7-6`).
+     *
+     * @generated from field: optional o11y_one.agentic.v1.GroupingRedirectV1 redirect = 2;
+     */
+    redirect?: GroupingRedirectV1 | undefined;
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunEventV1 events = 3;
+     */
+    events: AgentRunEventV1[];
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunLaneV1 lanes = 4;
+     */
+    lanes: AgentRunLaneV1[];
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunTimelineModeEffectV1 mode_effect = 5;
+     */
+    modeEffect?: AgentRunTimelineModeEffectV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunTimelineCursorV1 cursor = 6;
+     */
+    cursor?: AgentRunTimelineCursorV1 | undefined;
+    /**
+     * `P7-13`: the timeline's "this conversation is done" affordance READS this
+     * state. It computes no idle heuristic of its own, and there is no field here
+     * that would let it.
+     *
+     * @generated from field: o11y_one.agentic.v1.ConversationCompletenessV1 completeness = 7;
+     */
+    completeness?: ConversationCompletenessV1 | undefined;
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunEventKindCoverageV1 event_kind_coverage = 8;
+     */
+    eventKindCoverage: AgentRunEventKindCoverageV1[];
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunArtifactSourceCoverageV1 artifact_source_coverage = 9;
+     */
+    artifactSourceCoverage: AgentRunArtifactSourceCoverageV1[];
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunArtifactDiagnosticV1 artifact_diagnostics = 10;
+     */
+    artifactDiagnostics: AgentRunArtifactDiagnosticV1[];
+    /**
+     * NOT_SUPPORTED with `event_scoped_scores_not_projected`: no plane keys a
+     * score to a single span today. An absence with a reason, not an empty list a
+     * client would read as "unscored".
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 event_score_availability = 11;
+     */
+    eventScoreAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * J2's "downstream trace unavailable", typed. NOT_SUPPORTED with
+     * `span_links_reach_the_lake_without_attributes` — OTel's own relational
+     * mechanism survives ingest with its attributes dropped, so a span link cannot
+     * say WHY it links and a downstream reference cannot be built from it.
+     *
+     * @generated from field: o11y_one.agentic.v1.MetricAvailabilityV1 downstream_reference_availability = 12;
+     */
+    downstreamReferenceAvailability?: MetricAvailabilityV1 | undefined;
+    /**
+     * The earliest failure across the run's member traces (J2 step 4), reusing the
+     * trace viewer's own shape and fold.
+     *
+     * @generated from field: optional o11y_one.agentic.v1.TraceFirstFailureV1 first_failure = 13;
+     */
+    firstFailure?: TraceFirstFailureV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunTimelineCostDriverV1 cost_driver = 14;
+     */
+    costDriver?: AgentRunTimelineCostDriverV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceWindowV1 window = 15;
+     */
+    window?: TraceWindowV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceSpanPopulationBoundaryV1 boundary = 16;
+     */
+    boundary?: TraceSpanPopulationBoundaryV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.EvaluationFreshnessV1 freshness = 17;
+     */
+    freshness?: EvaluationFreshnessV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgenticEvaluationCapabilitiesV1 capabilities = 18;
+     */
+    capabilities?: AgenticEvaluationCapabilitiesV1 | undefined;
+    /**
+     * A member trace over the span cap refuses the WHOLE timeline with the
+     * observed count. A summary over part of a conversation is wrong rather than
+     * partial.
+     *
+     * @generated from field: optional o11y_one.agentic.v1.TraceReadRefusalV1 refusal = 19;
+     */
+    refusal?: TraceReadRefusalV1 | undefined;
+    /**
+     * Artifacts linked to the RUN rather than to any one span.
+     *
+     * Separate from `AgentRunEventV1.artifacts` deliberately: a link whose anchor
+     * is the run belongs to the run, and hanging it off the first event would put
+     * a relationship on a span nobody linked. Capped like every nested family.
+     *
+     * @generated from field: repeated o11y_one.agentic.v1.AgentRunArtifactSummaryV1 run_artifacts = 20;
+     */
+    runArtifacts: AgentRunArtifactSummaryV1[];
+};
+/**
+ * Describes the message o11y_one.agentic.v1.ListAgentRunEventsResponse.
+ * Use `create(ListAgentRunEventsResponseSchema)` to create a new message.
+ */
+export declare const ListAgentRunEventsResponseSchema: GenMessage<ListAgentRunEventsResponse>;
+/**
+ * `PLAN:497` / `AL-8` / `SM-12`. An audited logical revocation: a tombstone in
+ * the append-only correction ledger, never a delete of the immutable telemetry
+ * that carried the link.
+ *
+ * @generated from message o11y_one.agentic.v1.RevokeExternalArtifactLinkRequest
+ */
+export type RevokeExternalArtifactLinkRequest = Message<"o11y_one.agentic.v1.RevokeExternalArtifactLinkRequest"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.PrincipalRefV1 principal = 1;
+     */
+    principal?: PrincipalRefV1 | undefined;
+    /**
+     * @generated from field: bytes link_id = 2;
+     */
+    linkId: Uint8Array;
+    /**
+     * Machine-groupable, never prose: "why were my links revoked?" has to be
+     * answerable from a GROUP BY.
+     *
+     * @generated from field: string reason_code = 3;
+     */
+    reasonCode: string;
+    /**
+     * @generated from field: string idempotency_key = 4;
+     */
+    idempotencyKey: string;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.RevokeExternalArtifactLinkRequest.
+ * Use `create(RevokeExternalArtifactLinkRequestSchema)` to create a new message.
+ */
+export declare const RevokeExternalArtifactLinkRequestSchema: GenMessage<RevokeExternalArtifactLinkRequest>;
+/**
+ * @generated from message o11y_one.agentic.v1.RevokeExternalArtifactLinkResponse
+ */
+export type RevokeExternalArtifactLinkResponse = Message<"o11y_one.agentic.v1.RevokeExternalArtifactLinkResponse"> & {
+    /**
+     * The link as it now reads: `status = REVOKED`, everything else preserved.
+     *
+     * @generated from field: o11y_one.agentic.v1.ArtifactLinkV1 link = 1;
+     */
+    link?: ArtifactLinkV1 | undefined;
+    /**
+     * @generated from field: uint32 correction_sequence = 2;
+     */
+    correctionSequence: number;
+    /**
+     * @generated from field: optional string rejection_reason_code = 3;
+     */
+    rejectionReasonCode?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.RevokeExternalArtifactLinkResponse.
+ * Use `create(RevokeExternalArtifactLinkResponseSchema)` to create a new message.
+ */
+export declare const RevokeExternalArtifactLinkResponseSchema: GenMessage<RevokeExternalArtifactLinkResponse>;
+/**
+ * `PLAN:498` / `AL-14`. One resolve, one artifact, only after an explicit
+ * selection. List and timeline reads return POSTURE and never invoke a resolver.
+ *
+ * @generated from message o11y_one.agentic.v1.ResolveExternalArtifactLinkRequest
+ */
+export type ResolveExternalArtifactLinkRequest = Message<"o11y_one.agentic.v1.ResolveExternalArtifactLinkRequest"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.PrincipalRefV1 principal = 1;
+     */
+    principal?: PrincipalRefV1 | undefined;
+    /**
+     * @generated from field: bytes link_id = 2;
+     */
+    linkId: Uint8Array;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.ResolveExternalArtifactLinkRequest.
+ * Use `create(ResolveExternalArtifactLinkRequestSchema)` to create a new message.
+ */
+export declare const ResolveExternalArtifactLinkRequestSchema: GenMessage<ResolveExternalArtifactLinkRequest>;
+/**
+ * @generated from message o11y_one.agentic.v1.ResolveExternalArtifactLinkResponse
+ */
+export type ResolveExternalArtifactLinkResponse = Message<"o11y_one.agentic.v1.ResolveExternalArtifactLinkResponse"> & {
+    /**
+     * The outcome posture. `SM-13`'s six values.
+     *
+     * @generated from field: o11y_one.agentic.v1.ArtifactResolverPostureV1 posture = 1;
+     */
+    posture: ArtifactResolverPostureV1;
+    /**
+     * `resolver_not_configured` | `resolver_executor_not_shipped` |
+     * `resolver_denied_by_policy` | `link_not_found` | `link_revoked`.
+     *
+     * @generated from field: string reason_code = 2;
+     */
+    reasonCode: string;
+    /**
+     * Deliberately NOT a URL and NOT a credential. `AL-14` rule 3 and NN8: neither
+     * is stored, and neither is returned. When a resolver executor ships, the
+     * authorized content reference is what this grows — never a signed URL on a
+     * read model.
+     *
+     * @generated from field: google.protobuf.Timestamp attempted_at = 3;
+     */
+    attemptedAt?: Timestamp | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.ResolveExternalArtifactLinkResponse.
+ * Use `create(ResolveExternalArtifactLinkResponseSchema)` to create a new message.
+ */
+export declare const ResolveExternalArtifactLinkResponseSchema: GenMessage<ResolveExternalArtifactLinkResponse>;
+/**
+ * One trace, as the list renders it.
+ *
+ * The aggregate's own columns and nothing derived from a second plane.
+ * `AgentRunScorePostureV1` is DELIBERATELY ABSENT: it is a read of `eval_scores`
+ * and of the production-rule verdicts per trace, which is a third statement for
+ * a column a list sorts by but cannot act on. `GetAgentRun` carries the posture
+ * for the run a reader pivots to, which is where it is worth a read.
+ *
+ * @generated from message o11y_one.agentic.v1.AgentTraceRowV1
+ */
+export type AgentTraceRowV1 = Message<"o11y_one.agentic.v1.AgentTraceRowV1"> & {
+    /**
+     * Lowercase hex, as `AgentTraceHeaderV1.trace_id` spells it.
+     *
+     * @generated from field: string trace_id = 1;
+     */
+    traceId: string;
+    /**
+     * MIN(start) and MAX(end) over this trace's spans in the window. Absent when
+     * the plane carried no instant — zero is an absence, not the Unix epoch.
+     *
+     * @generated from field: google.protobuf.Timestamp started_at = 2;
+     */
+    startedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp ended_at = 3;
+     */
+    endedAt?: Timestamp | undefined;
+    /**
+     * `ended_at - started_at`, not a sum of span durations: a trace's wall time is
+     * its interval, and adding concurrent spans would over-count it.
+     *
+     * @generated from field: int64 wall_time_micros = 4;
+     */
+    wallTimeMicros: bigint;
+    /**
+     * @generated from field: uint32 span_count = 5;
+     */
+    spanCount: number;
+    /**
+     * Spans the ingest classifier marked failed. A trace with one is a trace the
+     * `errors_only` filter keeps.
+     *
+     * @generated from field: uint32 error_count = 6;
+     */
+    errorCount: number;
+    /**
+     * Distinct agent, model and tool names — the same column rules
+     * `agent_run/fold.rs` folds a RUN's counts from, so the two surfaces cannot
+     * drift into disagreeing about what a tool is.
+     *
+     * @generated from field: uint32 agent_count = 7;
+     */
+    agentCount: number;
+    /**
+     * @generated from field: uint32 model_count = 8;
+     */
+    modelCount: number;
+    /**
+     * @generated from field: uint32 tool_count = 9;
+     */
+    toolCount: number;
+    /**
+     * The dimensions, with their distinct counts: a trace whose spans state two
+     * deployments says so rather than letting one of them silently win.
+     *
+     * @generated from field: o11y_one.agentic.v1.AgentRunDimensionV1 customer = 10;
+     */
+    customer?: AgentRunDimensionV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunDimensionV1 deployment = 11;
+     */
+    deployment?: AgentRunDimensionV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentRunVersionContextV1 versions = 12;
+     */
+    versions?: AgentRunVersionContextV1 | undefined;
+    /**
+     * The run this trace is a member of, from `evaluation_agent_run_members`.
+     * Absent means the grouping pass has not reached this trace, NEVER that the
+     * trace belongs to no run.
+     *
+     * @generated from field: optional string agent_run_id = 13;
+     */
+    agentRunId?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgentTraceRowV1.
+ * Use `create(AgentTraceRowV1Schema)` to create a new message.
+ */
+export declare const AgentTraceRowV1Schema: GenMessage<AgentTraceRowV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.ListAgentTracesRequest
+ */
+export type ListAgentTracesRequest = Message<"o11y_one.agentic.v1.ListAgentTracesRequest"> & {
+    /**
+     * @generated from field: optional google.protobuf.Timestamp start = 1;
+     */
+    start?: Timestamp | undefined;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp end = 2;
+     */
+    end?: Timestamp | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgentTraceListFilterV1 filter = 3;
+     */
+    filter?: AgentTraceListFilterV1 | undefined;
+    /**
+     * @generated from field: optional uint32 limit = 4;
+     */
+    limit?: number | undefined;
+    /**
+     * Opaque keyset cursor over `(started_at DESC, trace_id DESC)`. Never an
+     * offset: an offset over a list whose rows move is a promise the span plane
+     * cannot keep.
+     *
+     * @generated from field: optional string page_token = 5;
+     */
+    pageToken?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.ListAgentTracesRequest.
+ * Use `create(ListAgentTracesRequestSchema)` to create a new message.
+ */
+export declare const ListAgentTracesRequestSchema: GenMessage<ListAgentTracesRequest>;
+/**
+ * @generated from message o11y_one.agentic.v1.ListAgentTracesResponse
+ */
+export type ListAgentTracesResponse = Message<"o11y_one.agentic.v1.ListAgentTracesResponse"> & {
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgentTraceRowV1 traces = 1;
+     */
+    traces: AgentTraceRowV1[];
+    /**
+     * @generated from field: optional string next_page_token = 2;
+     */
+    nextPageToken?: string | undefined;
+    /**
+     * @generated from field: bool has_more = 3;
+     */
+    hasMore: boolean;
+    /**
+     * Clamped IN BAND, with the reason, exactly as `ListAgentRuns` reports it.
+     *
+     * @generated from field: o11y_one.agentic.v1.TraceWindowV1 window = 4;
+     */
+    window?: TraceWindowV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.TraceSpanPopulationBoundaryV1 boundary = 5;
+     */
+    boundary?: TraceSpanPopulationBoundaryV1 | undefined;
+    /**
+     * `keyset_started_desc_late_data_resurfaces_at_head_v1`. A trace whose first
+     * span arrives late sorts by that span's instant, so it surfaces at the head
+     * of a fresh first page rather than inside an older cursor's continuation.
+     *
+     * @generated from field: string cursor_semantics_code = 6;
+     */
+    cursorSemanticsCode: string;
+    /**
+     * @generated from field: o11y_one.agentic.v1.EvaluationFreshnessV1 freshness = 7;
+     */
+    freshness?: EvaluationFreshnessV1 | undefined;
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgenticEvaluationCapabilitiesV1 capabilities = 8;
+     */
+    capabilities?: AgenticEvaluationCapabilitiesV1 | undefined;
+    /**
+     * @generated from field: optional o11y_one.agentic.v1.TraceReadRefusalV1 refusal = 9;
+     */
+    refusal?: TraceReadRefusalV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.ListAgentTracesResponse.
+ * Use `create(ListAgentTracesResponseSchema)` to create a new message.
+ */
+export declare const ListAgentTracesResponseSchema: GenMessage<ListAgentTracesResponse>;
+/**
+ * @generated from message o11y_one.agentic.v1.TraceInvestigationUnavailableReasonV1
+ */
+export type TraceInvestigationUnavailableReasonV1 = Message<"o11y_one.agentic.v1.TraceInvestigationUnavailableReasonV1"> & {
+    /**
+     * @generated from field: string section = 1;
+     */
+    section: string;
+    /**
+     * @generated from field: string reason_code = 2;
+     */
+    reasonCode: string;
+    /**
+     * @generated from field: string message = 3;
+     */
+    message: string;
+    /**
+     * @generated from field: bool retryable = 4;
+     */
+    retryable: boolean;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceInvestigationUnavailableReasonV1.
+ * Use `create(TraceInvestigationUnavailableReasonV1Schema)` to create a new message.
+ */
+export declare const TraceInvestigationUnavailableReasonV1Schema: GenMessage<TraceInvestigationUnavailableReasonV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.TraceInvestigationEvidenceLinkV1
+ */
+export type TraceInvestigationEvidenceLinkV1 = Message<"o11y_one.agentic.v1.TraceInvestigationEvidenceLinkV1"> & {
+    /**
+     * @generated from field: string evidence_type = 1;
+     */
+    evidenceType: string;
+    /**
+     * @generated from field: string evidence_id = 2;
+     */
+    evidenceId: string;
+    /**
+     * @generated from field: optional string trace_id = 3;
+     */
+    traceId?: string | undefined;
+    /**
+     * @generated from field: optional string span_id = 4;
+     */
+    spanId?: string | undefined;
+    /**
+     * @generated from field: optional string label = 5;
+     */
+    label?: string | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.TraceInvestigationEvidenceLinkV1.
+ * Use `create(TraceInvestigationEvidenceLinkV1Schema)` to create a new message.
+ */
+export declare const TraceInvestigationEvidenceLinkV1Schema: GenMessage<TraceInvestigationEvidenceLinkV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.AgenticEvidenceGraphNodeV1
+ */
+export type AgenticEvidenceGraphNodeV1 = Message<"o11y_one.agentic.v1.AgenticEvidenceGraphNodeV1"> & {
+    /**
+     * @generated from field: string node_id = 1;
+     */
+    nodeId: string;
+    /**
+     * @generated from field: string node_type = 2;
+     */
+    nodeType: string;
+    /**
+     * @generated from field: string label = 3;
+     */
+    label: string;
+    /**
+     * @generated from field: optional string status = 4;
+     */
+    status?: string | undefined;
+    /**
+     * Display-only facts about the node (a score's value, a run's grouping
+     * state), serialised JSON. A string rather than `google.protobuf.Struct`
+     * because the v2 contract carries no untyped document a service could branch
+     * on (`PLAN:1895`); this one is rendered, never read back.
+     *
+     * @generated from field: string metadata_json = 7;
+     */
+    metadataJson: string;
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.TraceInvestigationEvidenceLinkV1 evidence_links = 6;
+     */
+    evidenceLinks: TraceInvestigationEvidenceLinkV1[];
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgenticEvidenceGraphNodeV1.
+ * Use `create(AgenticEvidenceGraphNodeV1Schema)` to create a new message.
+ */
+export declare const AgenticEvidenceGraphNodeV1Schema: GenMessage<AgenticEvidenceGraphNodeV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.AgenticEvidenceGraphEdgeV1
+ */
+export type AgenticEvidenceGraphEdgeV1 = Message<"o11y_one.agentic.v1.AgenticEvidenceGraphEdgeV1"> & {
+    /**
+     * @generated from field: string source_node_id = 1;
+     */
+    sourceNodeId: string;
+    /**
+     * @generated from field: string target_node_id = 2;
+     */
+    targetNodeId: string;
+    /**
+     * @generated from field: string relationship = 3;
+     */
+    relationship: string;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgenticEvidenceGraphEdgeV1.
+ * Use `create(AgenticEvidenceGraphEdgeV1Schema)` to create a new message.
+ */
+export declare const AgenticEvidenceGraphEdgeV1Schema: GenMessage<AgenticEvidenceGraphEdgeV1>;
+/**
+ * @generated from message o11y_one.agentic.v1.AgenticEvidenceGraphV1
+ */
+export type AgenticEvidenceGraphV1 = Message<"o11y_one.agentic.v1.AgenticEvidenceGraphV1"> & {
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgenticEvidenceGraphNodeV1 nodes = 1;
+     */
+    nodes: AgenticEvidenceGraphNodeV1[];
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.AgenticEvidenceGraphEdgeV1 edges = 2;
+     */
+    edges: AgenticEvidenceGraphEdgeV1[];
+    /**
+     * @generated from field: bool truncated = 3;
+     */
+    truncated: boolean;
+    /**
+     * @generated from field: repeated o11y_one.agentic.v1.TraceInvestigationUnavailableReasonV1 unavailable_reasons = 4;
+     */
+    unavailableReasons: TraceInvestigationUnavailableReasonV1[];
+};
+/**
+ * Describes the message o11y_one.agentic.v1.AgenticEvidenceGraphV1.
+ * Use `create(AgenticEvidenceGraphV1Schema)` to create a new message.
+ */
+export declare const AgenticEvidenceGraphV1Schema: GenMessage<AgenticEvidenceGraphV1>;
+/**
+ * The two arms that survive v1. Six die with it — session, dataset item, eval
+ * job, experiment run item, release gate evaluation, annotation task — and
+ * every one of them names a v1-only concept.
+ *
+ * @generated from message o11y_one.agentic.v1.GetAgentEvidenceGraphRequest
+ */
+export type GetAgentEvidenceGraphRequest = Message<"o11y_one.agentic.v1.GetAgentEvidenceGraphRequest"> & {
+    /**
+     * @generated from oneof o11y_one.agentic.v1.GetAgentEvidenceGraphRequest.scope
+     */
+    scope: {
+        /**
+         * Lowercase hex, as `AgentTraceHeaderV1.trace_id` spells it.
+         *
+         * @generated from field: string trace_id = 1;
+         */
+        value: string;
+        case: "traceId";
+    } | {
+        /**
+         * A stale (`_MERGED_AWAY` / `_SPLIT_AWAY`) id resolves through the grouping
+         * redirect and answers with the CANONICAL run, never `NOT_FOUND` (`P7-6`).
+         *
+         * @generated from field: string agent_run_id = 2;
+         */
+        value: string;
+        case: "agentRunId";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    /**
+     * Default 64, clamped to 8..=512. The clamp is silent, exactly as the v1 verb
+     * clamps it: a client that asked for 4,000 nodes gets 512 and no field says
+     * so, and changing that is a contract change rather than a move.
+     *
+     * @generated from field: optional uint32 node_limit = 3;
+     */
+    nodeLimit?: number | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.GetAgentEvidenceGraphRequest.
+ * Use `create(GetAgentEvidenceGraphRequestSchema)` to create a new message.
+ */
+export declare const GetAgentEvidenceGraphRequestSchema: GenMessage<GetAgentEvidenceGraphRequest>;
+/**
+ * @generated from message o11y_one.agentic.v1.GetAgentEvidenceGraphResponse
+ */
+export type GetAgentEvidenceGraphResponse = Message<"o11y_one.agentic.v1.GetAgentEvidenceGraphResponse"> & {
+    /**
+     * @generated from field: o11y_one.agentic.v1.AgenticEvidenceGraphV1 graph = 1;
+     */
+    graph?: AgenticEvidenceGraphV1 | undefined;
+};
+/**
+ * Describes the message o11y_one.agentic.v1.GetAgentEvidenceGraphResponse.
+ * Use `create(GetAgentEvidenceGraphResponseSchema)` to create a new message.
+ */
+export declare const GetAgentEvidenceGraphResponseSchema: GenMessage<GetAgentEvidenceGraphResponse>;
+/**
+ * The design's five kinds, plus OTHER.
+ *
+ * OTHER is not a parse failure and not a sentinel: it means this build
+ * classified the span and it is none of the five. A closed enum of exactly the
+ * five would force every queue, worker and internal span into a category it
+ * does not belong to, which is the conflation this track exists to prevent.
+ *
+ * Precedence is FIRST MATCH WINS in the order TOOL, RETRIEVAL, LLM, DB, HTTP,
+ * OTHER, and it is stated because a span can satisfy two rules at once: an
+ * LLM-categorised span that names a tool is a TOOL call, because grouping it
+ * under LLM would hide the tool's own collapse count and p95 — the exact fact
+ * level 2 exists to show.
+ *
+ * @generated from enum o11y_one.agentic.v1.TraceOperationKindV1
+ */
+export declare enum TraceOperationKindV1 {
+    /**
+     * @generated from enum value: TRACE_OPERATION_KIND_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: TRACE_OPERATION_KIND_V1_LLM = 1;
+     */
+    LLM = 1,
+    /**
+     * @generated from enum value: TRACE_OPERATION_KIND_V1_TOOL = 2;
+     */
+    TOOL = 2,
+    /**
+     * @generated from enum value: TRACE_OPERATION_KIND_V1_DB = 3;
+     */
+    DB = 3,
+    /**
+     * @generated from enum value: TRACE_OPERATION_KIND_V1_HTTP = 4;
+     */
+    HTTP = 4,
+    /**
+     * @generated from enum value: TRACE_OPERATION_KIND_V1_RETRIEVAL = 5;
+     */
+    RETRIEVAL = 5,
+    /**
+     * @generated from enum value: TRACE_OPERATION_KIND_V1_OTHER = 6;
+     */
+    OTHER = 6
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.TraceOperationKindV1.
+ */
+export declare const TraceOperationKindV1Schema: GenEnum<TraceOperationKindV1>;
+/**
+ * The span's own status. UNSET is OpenTelemetry's default and is a different
+ * fact from OK: a span nobody set a status on has not been reported successful.
+ *
+ * @generated from enum o11y_one.agentic.v1.TraceSpanStatusV1
+ */
+export declare enum TraceSpanStatusV1 {
+    /**
+     * @generated from enum value: TRACE_SPAN_STATUS_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: TRACE_SPAN_STATUS_V1_UNSET = 1;
+     */
+    UNSET = 1,
+    /**
+     * @generated from enum value: TRACE_SPAN_STATUS_V1_OK = 2;
+     */
+    OK = 2,
+    /**
+     * @generated from enum value: TRACE_SPAN_STATUS_V1_ERROR = 3;
+     */
+    ERROR = 3
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.TraceSpanStatusV1.
+ */
+export declare const TraceSpanStatusV1Schema: GenEnum<TraceSpanStatusV1>;
+/**
+ * Why a span is in the needs-attention set. The design names exactly these
+ * three — "errors, warns, slow outliers".
+ *
+ * @generated from enum o11y_one.agentic.v1.TraceAttentionKindV1
+ */
+export declare enum TraceAttentionKindV1 {
+    /**
+     * @generated from enum value: TRACE_ATTENTION_KIND_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: TRACE_ATTENTION_KIND_V1_ERROR = 1;
+     */
+    ERROR = 1,
+    /**
+     * A span that recorded an exception event and did NOT fail. This is exactly
+     * the thing a person wants to see and no error filter shows.
+     *
+     * @generated from enum value: TRACE_ATTENTION_KIND_V1_WARN = 2;
+     */
+    WARN = 2,
+    /**
+     * @generated from enum value: TRACE_ATTENTION_KIND_V1_SLOW_OUTLIER = 3;
+     */
+    SLOW_OUTLIER = 3
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.TraceAttentionKindV1.
+ */
+export declare const TraceAttentionKindV1Schema: GenEnum<TraceAttentionKindV1>;
+/**
+ * How a span failed, in the lake's own vocabulary (wave 35, lane B).
+ *
+ * These are not new names. They are `transformation`'s `ErrorCategory` — the
+ * thirteen arms of `transformation/src/classifier/error.rs`, written into the
+ * `error_category` column at ingest by the classifier every span already goes
+ * through. Restating them here as an enum rather than passing the column's
+ * string through is what lets a client switch on a fault kind instead of
+ * matching prose, and the ordering below is that file's own.
+ *
+ * The column is NULL for a span that did not fail, so a value here is always a
+ * statement about a failure — with one exception, which is
+ * `UNCLASSIFIED`: a span that failed and whose category the classifier could
+ * not write. That is a different fact from `UNKNOWN`, which is the classifier
+ * saying "I looked and none of the twelve fit", and collapsing the two would
+ * hide how much of a trace's failure the classifier is actually reading.
+ *
+ * @generated from enum o11y_one.agentic.v1.TraceFaultCategoryV1
+ */
+export declare enum TraceFaultCategoryV1 {
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_TIMEOUT = 1;
+     */
+    TIMEOUT = 1,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_AUTH = 2;
+     */
+    AUTH = 2,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_RATE_LIMIT = 3;
+     */
+    RATE_LIMIT = 3,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_NOT_FOUND = 4;
+     */
+    NOT_FOUND = 4,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_BAD_REQUEST = 5;
+     */
+    BAD_REQUEST = 5,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_CONFLICT = 6;
+     */
+    CONFLICT = 6,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_UNAVAILABLE = 7;
+     */
+    UNAVAILABLE = 7,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_DATA_LOSS = 8;
+     */
+    DATA_LOSS = 8,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_SERVER_ERROR = 9;
+     */
+    SERVER_ERROR = 9,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_NETWORK = 10;
+     */
+    NETWORK = 10,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_CLIENT_ERROR = 11;
+     */
+    CLIENT_ERROR = 11,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_APPLICATION = 12;
+     */
+    APPLICATION = 12,
+    /**
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_UNKNOWN = 13;
+     */
+    UNKNOWN = 13,
+    /**
+     * The span failed and carried no category. Never merged into UNKNOWN.
+     *
+     * @generated from enum value: TRACE_FAULT_CATEGORY_V1_UNCLASSIFIED = 14;
+     */
+    UNCLASSIFIED = 14
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.TraceFaultCategoryV1.
+ */
+export declare const TraceFaultCategoryV1Schema: GenEnum<TraceFaultCategoryV1>;
+/**
+ * Where a span's money came from. Two provenances, and neither is a bill.
+ *
+ * The operator's ruling of 2026-08-28: *"If client instrumented cost, use that,
+ * else, use the stock provider rate"*. Both halves are on the wire as their own
+ * value, because a number a customer's own code stated and a number this build
+ * computed off a published list price are different evidence, and a client that
+ * cannot tell them apart cannot say which one it is rendering.
+ *
+ * @generated from enum o11y_one.agentic.v1.TraceSpanCostProvenanceV1
+ */
+export declare enum TraceSpanCostProvenanceV1 {
+    /**
+     * @generated from enum value: TRACE_SPAN_COST_PROVENANCE_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * The span's own `gen_ai.usage.cost` attribute, surfaced VERBATIM. Never
+     * recomputed, never reconciled against the tokens beside it: a client that
+     * instrumented its own cost has stated a fact, and a server that "corrects"
+     * it has replaced evidence with arithmetic.
+     *
+     * @generated from enum value: TRACE_SPAN_COST_PROVENANCE_V1_CLIENT_STATED = 1;
+     */
+    CLIENT_STATED = 1,
+    /**
+     * The span's observed tokens priced at the rate registry's CURRENT list row
+     * for the model the span itself named. An estimate, explicitly — the client
+     * renders it as "estimated from the provider's pricing list, as of <date>",
+     * where the date is `TraceSpanRateBasisV1.rate_checked_at`. It is not a bill,
+     * it is not what the provider charged, and it enters no ledger.
+     *
+     * @generated from enum value: TRACE_SPAN_COST_PROVENANCE_V1_LIST_RATE_ESTIMATE = 2;
+     */
+    LIST_RATE_ESTIMATE = 2
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.TraceSpanCostProvenanceV1.
+ */
+export declare const TraceSpanCostProvenanceV1Schema: GenEnum<TraceSpanCostProvenanceV1>;
+/**
+ * What a trace read can refuse with, and why each one is its own kind. A caller
+ * told only "invalid argument" cannot act; each of these names a different next
+ * step, and none of them is "we returned a partial answer". A cut trace is not
+ * among them: it is served, and its critical path carries the availability.
+ *
+ * @generated from enum o11y_one.agentic.v1.TraceReadRefusalKindV1
+ */
+export declare enum TraceReadRefusalKindV1 {
+    /**
+     * @generated from enum value: TRACE_READ_REFUSAL_KIND_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * The window held no spans for this trace id. Distinct from the cap breach
+     * below: "we looked and found none" is not "we looked and found too many".
+     *
+     * @generated from enum value: TRACE_READ_REFUSAL_KIND_V1_TRACE_NOT_FOUND = 1;
+     */
+    TRACE_NOT_FOUND = 1,
+    /**
+     * More spans than `TraceSpanPopulationBoundaryV1.max_spans`. Refused WHOLE:
+     * a critical path computed over the first 10,000 spans of a 40,000-span
+     * trace is not a partial critical path, it is a WRONG one, and a client
+     * cannot tell.
+     *
+     * @generated from enum value: TRACE_READ_REFUSAL_KIND_V1_SPAN_POPULATION_EXCEEDS_CAP = 2;
+     */
+    SPAN_POPULATION_EXCEEDS_CAP = 2,
+    /**
+     * Deprecated: never constructed. The fold serves a cut trace and marks its
+     * critical path NOT_OBSERVED with reason_code
+     * trace_root_span_not_in_population; render that.
+     *
+     * @generated from enum value: TRACE_READ_REFUSAL_KIND_V1_TRACE_ROOT_NOT_IN_POPULATION = 3 [deprecated = true];
+     * @deprecated
+     */
+    TRACE_ROOT_NOT_IN_POPULATION = 3,
+    /**
+     * The requested window ends before the oldest instant the span plane will
+     * answer for. Distinct from `TRACE_NOT_FOUND` on purpose, and the distinction
+     * is the whole typed-absence invariant: "we looked and found none" and "we do
+     * not look that far back" are different facts, and only one of them is about
+     * the caller's trace.
+     *
+     * @generated from enum value: TRACE_READ_REFUSAL_KIND_V1_WINDOW_OUTSIDE_RETAINED_LOOKBACK = 4;
+     */
+    WINDOW_OUTSIDE_RETAINED_LOOKBACK = 4,
+    /**
+     * The span plane declined to spend the memory the scan asked for, so the read
+     * was refused BEFORE it ran: nothing about the trace is known — not that it is
+     * large, not that it is absent, not that it is anything. Retry later, or ask
+     * for a narrower window. Its own kind rather than an `INTERNAL`, because a
+     * refusal a caller can retry and a failure a caller can only report are
+     * different facts, and the first one spent eight of eight reads looking like
+     * the second.
+     *
+     * @generated from enum value: TRACE_READ_REFUSAL_KIND_V1_READ_BUDGET_EXHAUSTED = 5;
+     */
+    READ_BUDGET_EXHAUSTED = 5
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.TraceReadRefusalKindV1.
+ */
+export declare const TraceReadRefusalKindV1Schema: GenEnum<TraceReadRefusalKindV1>;
+/**
+ * The first word on the agent-run header (`BP:755`).
+ *
+ * `PLAN:1683` asks for an "outcome" and neither the plan nor `0b` §4 defines the
+ * vocabulary — handoff doc 11 §9 Q1 raises exactly that. This is the answer, and
+ * its derivation is published as `agent_run_outcome_v1` in the capability set so
+ * a reader can argue with the rule rather than only with the word.
+ *
+ * `_UNKNOWN` IS A VERDICT, NOT A NULL. It is what this build says when the
+ * conversation is still `_OPEN` — a run in flight has not had an outcome yet —
+ * and when no member span reported a status at all. `UNSET is not OK` on one
+ * span; a whole run of them is not a successful run either.
+ *
+ * @generated from enum o11y_one.agentic.v1.AgentRunOutcomeV1
+ */
+export declare enum AgentRunOutcomeV1 {
+    /**
+     * @generated from enum value: AGENT_RUN_OUTCOME_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * Carries `outcome_unknown_reason_code`, always.
+     *
+     * @generated from enum value: AGENT_RUN_OUTCOME_V1_UNKNOWN = 1;
+     */
+    UNKNOWN = 1,
+    /**
+     * At least one member span reported OK, none failed, no rule judged it badly.
+     *
+     * @generated from enum value: AGENT_RUN_OUTCOME_V1_SUCCEEDED = 2;
+     */
+    SUCCEEDED = 2,
+    /**
+     * Something recorded a fault without failing (`warned_span_count > 0`).
+     *
+     * @generated from enum value: AGENT_RUN_OUTCOME_V1_DEGRADED = 3;
+     */
+    DEGRADED = 3,
+    /**
+     * A member span reported an error status.
+     *
+     * @generated from enum value: AGENT_RUN_OUTCOME_V1_FAILED = 4;
+     */
+    FAILED = 4,
+    /**
+     * A production rule (§6, wave 39) returned a failing verdict over this run's
+     * work. It OUTRANKS `_FAILED`, deliberately: the span plane knows whether the
+     * machinery worked and the rule plane knows whether the work was acceptable,
+     * and J2's operator arrived holding the second question.
+     *
+     * @generated from enum value: AGENT_RUN_OUTCOME_V1_POLICY_FAILED = 5;
+     */
+    POLICY_FAILED = 5
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.AgentRunOutcomeV1.
+ */
+export declare const AgentRunOutcomeV1Schema: GenEnum<AgentRunOutcomeV1>;
+/**
+ * Which input the derivation consulted, so "why does it say Failed" is returned
+ * data rather than a frontend heuristic — `0b P7-3`'s rule for grouping
+ * confidence, applied to the field beside it.
+ *
+ * @generated from enum o11y_one.agentic.v1.AgentRunOutcomeInputKindV1
+ */
+export declare enum AgentRunOutcomeInputKindV1 {
+    /**
+     * @generated from enum value: AGENT_RUN_OUTCOME_INPUT_KIND_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: AGENT_RUN_OUTCOME_INPUT_KIND_V1_CONVERSATION_COMPLETENESS = 1;
+     */
+    CONVERSATION_COMPLETENESS = 1,
+    /**
+     * @generated from enum value: AGENT_RUN_OUTCOME_INPUT_KIND_V1_PRODUCTION_RULE_VERDICT = 2;
+     */
+    PRODUCTION_RULE_VERDICT = 2,
+    /**
+     * @generated from enum value: AGENT_RUN_OUTCOME_INPUT_KIND_V1_MEMBER_SPAN_FAILURE = 3;
+     */
+    MEMBER_SPAN_FAILURE = 3,
+    /**
+     * @generated from enum value: AGENT_RUN_OUTCOME_INPUT_KIND_V1_MEMBER_SPAN_WARNING = 4;
+     */
+    MEMBER_SPAN_WARNING = 4,
+    /**
+     * @generated from enum value: AGENT_RUN_OUTCOME_INPUT_KIND_V1_MEMBER_SPAN_STATUS = 5;
+     */
+    MEMBER_SPAN_STATUS = 5
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.AgentRunOutcomeInputKindV1.
+ */
+export declare const AgentRunOutcomeInputKindV1Schema: GenEnum<AgentRunOutcomeInputKindV1>;
+/**
+ * J2 step 7 — "is this failure already covered?" (`BP:482`, A2 gap `G21`).
+ *
+ * `_UNKNOWN` IS A REAL VERDICT AND NEVER MEANS "NOT COVERED". `0b` §4.5 says so
+ * in as many words, and the distinction is the whole value of the block: telling
+ * an operator "not covered" about a run whose lineage this build cannot resolve
+ * would send them to write a duplicate dataset case.
+ *
+ * @generated from enum o11y_one.agentic.v1.AgentRunCoverageVerdictV1
+ */
+export declare enum AgentRunCoverageVerdictV1 {
+    /**
+     * @generated from enum value: AGENT_RUN_COVERAGE_VERDICT_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * The lineage plane was asked and cannot answer for this run. Carries a reason.
+     *
+     * @generated from enum value: AGENT_RUN_COVERAGE_VERDICT_V1_UNKNOWN = 1;
+     */
+    UNKNOWN = 1,
+    /**
+     * Asked, answered, and nothing references any member trace.
+     *
+     * @generated from enum value: AGENT_RUN_COVERAGE_VERDICT_V1_NOT_COVERED = 2;
+     */
+    NOT_COVERED = 2,
+    /**
+     * A dataset case or draft names a member trace as its source.
+     *
+     * @generated from enum value: AGENT_RUN_COVERAGE_VERDICT_V1_COVERED_BY_DATASET = 3;
+     */
+    COVERED_BY_DATASET = 3,
+    /**
+     * ...and an evaluation run pinned one of those case revisions.
+     *
+     * @generated from enum value: AGENT_RUN_COVERAGE_VERDICT_V1_COVERED_BY_EVALUATION = 4;
+     */
+    COVERED_BY_EVALUATION = 4
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.AgentRunCoverageVerdictV1.
+ */
+export declare const AgentRunCoverageVerdictV1Schema: GenEnum<AgentRunCoverageVerdictV1>;
+/**
+ * `0b P7-15`, FROZEN. Three modes, and raw trace is not one of them.
+ *
+ * @generated from enum o11y_one.agentic.v1.AgentRunTimelineModeV1
+ */
+export declare enum AgentRunTimelineModeV1 {
+    /**
+     * @generated from enum value: AGENT_RUN_TIMELINE_MODE_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * Semantic operations grouped by agent and task (`BP:772`). The unfiltered
+     * timeline: this mode never filters server-side and says so.
+     *
+     * @generated from enum value: AGENT_RUN_TIMELINE_MODE_V1_SUMMARY = 1;
+     */
+    SUMMARY = 1,
+    /**
+     * Failed/degraded work PLUS causal parents (`BP:773`). A failed tool call
+     * without the model turn that issued it is a leaf with no story.
+     *
+     * @generated from enum value: AGENT_RUN_TIMELINE_MODE_V1_FAILURES_ONLY = 2;
+     */
+    FAILURES_ONLY = 2,
+    /**
+     * The work determining end-to-end latency (`BP:774`), computed by the trace
+     * viewer's own `latest_finishing_child_chain_v1` so "critical" means one
+     * thing across this product.
+     *
+     * @generated from enum value: AGENT_RUN_TIMELINE_MODE_V1_CRITICAL_PATH = 3;
+     */
+    CRITICAL_PATH = 3
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.AgentRunTimelineModeV1.
+ */
+export declare const AgentRunTimelineModeV1Schema: GenEnum<AgentRunTimelineModeV1>;
+/**
+ * The six event families this build has an ingest source for.
+ *
+ * A failure is a STATE on an event, not a kind: an errored tool call is
+ * `..._TOOL` with `is_error`, so "how many tool calls did this run make?" stays
+ * answerable from the kind alone. `..._ERROR` is for a span whose only semantic
+ * is that something broke.
+ *
+ * @generated from enum o11y_one.agentic.v1.AgentRunEventKindV1
+ */
+export declare enum AgentRunEventKindV1 {
+    /**
+     * @generated from enum value: AGENT_RUN_EVENT_KIND_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: AGENT_RUN_EVENT_KIND_V1_MODEL = 1;
+     */
+    MODEL = 1,
+    /**
+     * @generated from enum value: AGENT_RUN_EVENT_KIND_V1_TOOL = 2;
+     */
+    TOOL = 2,
+    /**
+     * @generated from enum value: AGENT_RUN_EVENT_KIND_V1_RETRIEVAL = 3;
+     */
+    RETRIEVAL = 3,
+    /**
+     * @generated from enum value: AGENT_RUN_EVENT_KIND_V1_DOWNSTREAM = 4;
+     */
+    DOWNSTREAM = 4,
+    /**
+     * @generated from enum value: AGENT_RUN_EVENT_KIND_V1_ERROR = 5;
+     */
+    ERROR = 5,
+    /**
+     * @generated from enum value: AGENT_RUN_EVENT_KIND_V1_GENERIC = 6;
+     */
+    GENERIC = 6
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.AgentRunEventKindV1.
+ */
+export declare const AgentRunEventKindV1Schema: GenEnum<AgentRunEventKindV1>;
+/**
+ * `0b P7-16`. How a client applies an event it just received.
+ *
+ * @generated from enum o11y_one.agentic.v1.AgentRunEventDeliveryV1
+ */
+export declare enum AgentRunEventDeliveryV1 {
+    /**
+     * @generated from enum value: AGENT_RUN_EVENT_DELIVERY_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * New, after the cursor's position.
+     *
+     * @generated from enum value: AGENT_RUN_EVENT_DELIVERY_V1_APPEND = 1;
+     */
+    APPEND = 1,
+    /**
+     * At or before the cursor's position, re-emitted because the watermark moved.
+     * Keyed by `event_id`; apply idempotently. Never a page reshuffle.
+     *
+     * @generated from enum value: AGENT_RUN_EVENT_DELIVERY_V1_UPSERT = 2;
+     */
+    UPSERT = 2
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.AgentRunEventDeliveryV1.
+ */
+export declare const AgentRunEventDeliveryV1Schema: GenEnum<AgentRunEventDeliveryV1>;
+/**
+ * Which spelling produced a normalized attribute (`PLAN:1720`, semconv registry
+ * §6.8). A verdict a client groups by, not a hint.
+ *
+ * @generated from enum o11y_one.agentic.v1.AgentRunAttributeSourceV1
+ */
+export declare enum AgentRunAttributeSourceV1 {
+    /**
+     * @generated from enum value: AGENT_RUN_ATTRIBUTE_SOURCE_V1_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: AGENT_RUN_ATTRIBUTE_SOURCE_V1_CANONICAL = 1;
+     */
+    CANONICAL = 1,
+    /**
+     * The deprecated `o11y.*` spelling. Every span in this build, until the
+     * registry's `1C-5` rename lands the canonical columns.
+     *
+     * @generated from enum value: AGENT_RUN_ATTRIBUTE_SOURCE_V1_LEGACY_ALIAS = 2;
+     */
+    LEGACY_ALIAS = 2,
+    /**
+     * @generated from enum value: AGENT_RUN_ATTRIBUTE_SOURCE_V1_BOTH_EQUAL = 3;
+     */
+    BOTH_EQUAL = 3,
+    /**
+     * Both spellings, different values. Canonical wins and both are recorded.
+     *
+     * @generated from enum value: AGENT_RUN_ATTRIBUTE_SOURCE_V1_CONFLICT = 4;
+     */
+    CONFLICT = 4
+}
+/**
+ * Describes the enum o11y_one.agentic.v1.AgentRunAttributeSourceV1.
+ */
+export declare const AgentRunAttributeSourceV1Schema: GenEnum<AgentRunAttributeSourceV1>;
+/**
+ * The trace viewer's read plane.
+ *
+ * Served by the process that holds `UnifiedTelemetryQueryEngine`, because span
+ * rows are reachable through nothing else. Two RPCs, one bounded span scan
+ * each, so a screen costs two scans rather than five.
+ *
+ * @generated from service o11y_one.agentic.v1.AgenticTraceViewService
+ */
+export declare const AgenticTraceViewService: GenService<{
+    /**
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.GetAgentTraceDetail
+     */
+    getAgentTraceDetail: {
+        methodKind: "unary";
+        input: typeof GetAgentTraceDetailRequestSchema;
+        output: typeof GetAgentTraceDetailResponseSchema;
+    };
+    /**
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.ListAgentTraceSpans
+     */
+    listAgentTraceSpans: {
+        methodKind: "unary";
+        input: typeof ListAgentTraceSpansRequestSchema;
+        output: typeof ListAgentTraceSpansResponseSchema;
+    };
+    /**
+     * ---- end wave 41 lane A ----
+     *
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.ConfirmAgentRunGrouping
+     */
+    confirmAgentRunGrouping: {
+        methodKind: "unary";
+        input: typeof ConfirmAgentRunGroupingRequestSchema;
+        output: typeof ConfirmAgentRunGroupingResponseSchema;
+    };
+    /**
+     * ---- wave 41 lane B: summary index ----
+     *
+     * The Production > Agent runs list and the run header (`PLAN:491`).
+     *
+     * Both are served from the MAINTAINED projection (`P7-14`, `PLAN:1687`) and
+     * neither touches the query engine: the index pass on the preparation worker
+     * does the scanning, and `agent_trace_span_scans_issued()` not moving across
+     * these two calls is how that is proved rather than asserted.
+     *
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.ListAgentRuns
+     */
+    listAgentRuns: {
+        methodKind: "unary";
+        input: typeof ListAgentRunsRequestSchema;
+        output: typeof ListAgentRunsResponseSchema;
+    };
+    /**
+     * W-V1-1 (D2). The `/traces` list, in two reads. It sits beside
+     * `ListAgentRuns` because the two are the same screen at two altitudes —
+     * every trace, and the runs those traces group into.
+     *
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.ListAgentTraces
+     */
+    listAgentTraces: {
+        methodKind: "unary";
+        input: typeof ListAgentTracesRequestSchema;
+        output: typeof ListAgentTracesResponseSchema;
+    };
+    /**
+     * W-V1-1 (D3). The trace sheet's and the agent-run screen's evidence graph,
+     * built by the SAME builders the v1 verb now calls: the two arms moved here
+     * rather than being copied, so the two services cannot answer differently
+     * for the same scope while both exist.
+     *
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.GetAgentEvidenceGraph
+     */
+    getAgentEvidenceGraph: {
+        methodKind: "unary";
+        input: typeof GetAgentEvidenceGraphRequestSchema;
+        output: typeof GetAgentEvidenceGraphResponseSchema;
+    };
+    /**
+     * ---- end wave 41 lane B ----
+     *
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.GetAgentRun
+     */
+    getAgentRun: {
+        methodKind: "unary";
+        input: typeof GetAgentRunRequestSchema;
+        output: typeof GetAgentRunResponseSchema;
+    };
+    /**
+     * ---- wave 41 lane C: timeline ----
+     *
+     * The conversation timeline (`PLAN:492`) and the three external-artifact verbs
+     * (`PLAN:495`-`:498`).
+     *
+     * They live on this service for the reason the file header already gives: span
+     * rows are reachable only through `UnifiedTelemetryQueryEngine`, and a read
+     * model over spans is a query-engine read model or it is nothing. The three
+     * verbs join them because the timeline is where an artifact link is READ, and
+     * splitting the write of a link from the read of it across two services would
+     * make "the RPC fallback produces the identical typed read model"
+     * (exit `:1733`) a claim about two codebases instead of one.
+     *
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.ListAgentRunEvents
+     */
+    listAgentRunEvents: {
+        methodKind: "unary";
+        input: typeof ListAgentRunEventsRequestSchema;
+        output: typeof ListAgentRunEventsResponseSchema;
+    };
+    /**
+     * `AL-9`/`AL-10`: for unavailable instrumentation, backfill, correction or
+     * revocation ONLY — never the normal instrumentation path. `MUTATION_ACK`
+     * class, authorized principal, one audit row per call, rate-limited as a write
+     * surface. Request and response are `artifact.proto`'s, which minted them and
+     * left the surface to "the increment that wires it".
+     *
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.LinkExternalArtifact
+     */
+    linkExternalArtifact: {
+        methodKind: "unary";
+        input: typeof LinkExternalArtifactRequestSchema;
+        output: typeof LinkExternalArtifactResponseSchema;
+    };
+    /**
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.RevokeExternalArtifactLink
+     */
+    revokeExternalArtifactLink: {
+        methodKind: "unary";
+        input: typeof RevokeExternalArtifactLinkRequestSchema;
+        output: typeof RevokeExternalArtifactLinkResponseSchema;
+    };
+    /**
+     * `AL-14`: one authorized, explicitly selected artifact. There is no batch
+     * resolve, because a batch resolve is a fan-out with a nicer name.
+     *
+     * ---- end wave 41 lane C ----
+     *
+     * @generated from rpc o11y_one.agentic.v1.AgenticTraceViewService.ResolveExternalArtifactLink
+     */
+    resolveExternalArtifactLink: {
+        methodKind: "unary";
+        input: typeof ResolveExternalArtifactLinkRequestSchema;
+        output: typeof ResolveExternalArtifactLinkResponseSchema;
+    };
+}>;