Store money as authoritative microdollars by mariusvniekerk · Pull Request #1224 · kenn-io/agentsview

mariusvniekerk · 2026-07-22T14:35:08Z

AgentsView currently carries currency as binary floating-point dollars across ingestion, storage, aggregation, and public contracts. That makes rounding behavior depend on where conversion happens and allows storage backends or API clients to disagree about the same charge.

This change makes signed int64 microdollars the single machine representation. Public money values use semantic fields containing {"microdollars": ...}; CLI tables and UI labels continue to render ordinary dollars. SQLite and PostgreSQL convert legacy columns transactionally after validating them, while the disposable DuckDB mirror bumps its schema and rebuilds.

The deliberate tradeoff is a broad contract change: export schemas are bumped and old floating-point fields are removed instead of retained through dual reads, writes, or aliases. Reviewers should focus on integer arithmetic and rounding boundaries, migration failure behavior, and parity across the supported storage backends.

^{generated by a clanker}

roborev-ci · 2026-07-22T14:41:08Z

roborev: Combined Review (`dcc0736`)

High- and medium-severity issues must be resolved before merge.

High

internal/pricing/cmd/litellm-snapshot/main.go:38 — The expected snapshot SHA changed while its immutable commit ref did not. Snapshot restoration will fail checksum validation, blocking every Go-compiling Make target that depends on pricing-snapshot.
- Fix: Publish the microdollar-format snapshot at a new artifact commit and update both the pinned ref and SHA.

Medium

internal/postgres/schema.go:2088 — CheckSchemaCompat probes only usage_events.id, allowing a legacy schema with cost_usd to pass startup validation even though reads require cost_microdollars. Existing model_pricing tables are also not checked for the required microdollar columns, so pg serve may start and later fail usage queries.
- Fix: Probe cost_microdollars and, when model_pricing exists, all required microdollar columns; add coverage for legacy schemas.

Reviewers: 2 done | Synthesis: codex, 8s | Total: 7m47s

roborev-ci · 2026-07-24T22:20:30Z

roborev: Combined Review (`dcc0736`)

The PR has one build-blocking issue and two migration/configuration regressions that should be fixed before merge.

High

internal/pricing/cmd/litellm-snapshot/main.go:37 — The expected snapshot checksum was changed to ea928d..., but defaultSnapshotRef still identifies an artifact with checksum bef918.... Every Make target invoking pricing-snapshot, including builds and tests, will fail with a SHA256 mismatch.
- Fix: Point defaultSnapshotRef to the artifact commit containing the regenerated microdollar snapshot and keep the reference and checksum synchronized.

Medium

internal/db/money_migration.go:166 — Migrated Cursor rows retain deduplication keys derived from old floating-point cost strings, while new events use integer microdollars in cursorUsageEventDedupKey. Re-fetching an overlapping window after upgrade can insert duplicate historical events and double-count usage and cost.
- Fix: Transactionally regenerate migrated keys using the new canonical representation, or retain a stable, unit-independent key algorithm.
internal/config/config.go:1215 — Legacy custom-pricing keys such as input and output are silently ignored. The new fields remain zero, but the nonempty model entry becomes an authoritative zero-price override, changing previously configured costs to $0.
- Fix: Detect legacy or undecoded keys under custom_model_pricing, return a clear migration error, and add a regression test using the legacy keys.

Reviewers: 2 done | Synthesis: codex, 16s | Total: 28m18s

roborev-ci · 2026-07-25T02:21:19Z

roborev: Combined Review (`6e08b51`)

The microdollar migration has three medium-severity correctness and compatibility issues; no security vulnerabilities were identified.

Medium

DuckDB cost rounding differs from SQLite/PostgreSQL — internal/duckdb/analytics_usage.go:3644
DuckDB aggregates token counts before calling CostForTokens, causing rounding once per aggregate rather than once per usage row. Sub-microdollar rows can therefore produce inconsistent totals across backends. Price each deduplicated usage row independently in integer microdollars, then sum the row costs.
PostgreSQL fingerprints use lossy floating-point costs — internal/postgres/push_fingerprint.go:780, internal/postgres/push.go:2894
PostgreSQL scans cost_microdollars as sql.NullFloat64 and formats it with %g, while SQLite uses exact integers. This can lose precision or produce different representations, leading to incorrect fingerprint comparisons and unnecessary replacements. Use sql.NullInt64 and %d, and add a cross-backend fingerprint parity test.
Legacy custom-pricing configuration is silently ignored — internal/config/config.go:1043
TOML keys such as input and output are ignored, leaving the new microdollar fields at zero while accepting the configuration. Existing pricing overrides can therefore be silently disabled. Reject legacy or unknown pricing fields with a migration-oriented error, or migrate them explicitly.

Reviewers: 2 done | Synthesis: codex, 11s | Total: 9m4s

roborev-ci · 2026-07-25T02:31:03Z

roborev: Combined Review (`e9071b0`)

High-risk deduplication regression could double-count Cursor usage after upgrades; four additional medium-severity migration and backend-parity issues remain.

High

internal/db/cursor_usage_events.go:122 — Cursor deduplication now hashes integer microdollar values, while migrated rows retain keys derived from legacy floating-point values. Refetching overlapping events after an upgrade generates different keys and inserts duplicates, double-counting usage.
- Fix: Preserve the legacy canonical key format or atomically migrate existing dedup keys. Add a test proving that post-migration refetches are ignored.

Medium

internal/postgres/push.go:2894, internal/postgres/push_fingerprint.go:780 — PostgreSQL fingerprints scan integer microdollar costs as float64 and format them with %g, unlike SQLite’s exact integer representation. Large values may lose precision or use exponent notation, causing perpetual fingerprint mismatches and repeated pushes.
- Fix: Scan costs as sql.NullInt64 and format them with %d in both paths. Add backend-parity tests with large values.
internal/duckdb/schema.go:13 — The DuckDB schema version was reduced from 5 to 4 despite incompatible column and type changes, making mirror metadata ambiguous and violating the rebuild-on-schema-change invariant.
- Fix: Advance the schema to the next unique version, currently 6, and update related tests and comments.
internal/config/config.go:419, internal/config/config.go:1241 — Legacy custom-pricing keys such as input and output are silently ignored during TOML decoding, while the resulting empty rate record is accepted. Existing configurations can therefore override model pricing with zero-cost rates.
- Fix: Reject unknown or legacy pricing keys with a migration-oriented configuration error. Add coverage for legacy configurations.
internal/postgres/schema.go:429 — The PostgreSQL migration applies ROUND to double precision, whose midpoint behavior may differ from the required half-away-from-zero rounding used elsewhere. Half-microdollar legacy values can migrate differently between PostgreSQL and SQLite.
- Fix: Convert values to numeric before rounding or use an explicit half-away-from-zero expression. Add midpoint migration-parity tests.

Reviewers: 2 done | Synthesis: codex, 14s | Total: 11m45s

Floating-point dollar values currently cross storage, aggregation, synchronization, and public contracts, so the implementation needs one exact authority rather than a database-only conversion. Document the approved microdollar representation, destructive-free forward migrations, integer pricing arithmetic, machine JSON contract, and mandatory dollar-formatted human presentation before implementation begins.

The money conversion crosses parsers, three storage backends, exports, APIs, CLI rendering, and the frontend, and cannot safely use temporary float compatibility adapters. Record the test-first execution order, backend migration gates, exact public contract, and verification boundaries before changing production code.

Money needs one exact value and arithmetic boundary before storage and public contracts can stop relying on binary floating-point dollars. Add checked signed microdollar sums, exact scaled-decimal parsing, wide token-rate multiplication with row-level rounding, and integer-only dollar presentation that safely handles the full int64 range.

Floating-point dollars allowed binary rounding to leak through ingestion, storage, aggregation, exports, and APIs. Use one signed int64 microdollar authority so every machine-facing monetary value has an exact representation and checked arithmetic. SQLite and PostgreSQL migrate legacy values transactionally, while the disposable DuckDB mirror rebuilds on its schema bump. Human-facing CLI tables and frontend labels continue to render ordinary dollar amounts from the exact value.

Clean CI and release checkouts cannot reuse the locally converted pricing snapshot. Pin the artifact commit that carries the exact-money schema so restoration validates against the existing digest and builds no longer fetch the obsolete floating-point payload.

Current main expanded the OpenAPI contract while its checked-in client still reflected the earlier schema. Regenerate it alongside the money contract and adapt optional embedding-store calls so frontend type checking remains authoritative after the rebase.

The microdollar migration added provenance to session-backed daily rows but left Cursor's PostgreSQL branch one column short, making every daily usage UNION fail at runtime. Keep the branch shape and pgtest fixtures on the exact-money contract so integration CI exercises the same schema as production.

Persisted Cursor dedup keys and PostgreSQL push fingerprints are identity boundaries: changing their canonical representation can duplicate usage or continually republish otherwise unchanged sessions. Keep those boundaries stable while retaining integer-exact costs beyond floating-point precision. Legacy configuration must also fail loudly instead of silently installing zero-cost overrides, and backend migrations must agree on midpoint rounding. Advance the disposable DuckDB schema past every released shape so stale mirrors rebuild rather than masquerading as current.

roborev-ci · 2026-07-27T02:34:15Z

roborev: Combined Review (`93e685b`)

The PR needs changes for three medium-severity correctness and compatibility issues.

Medium

DuckDB cost aggregation differs from SQLite/PostgreSQL — internal/duckdb/analytics_usage.go:3650, internal/duckdb/analytics_usage.go:3990
DuckDB sums token counts before calculating and rounding costs, while SQLite and PostgreSQL calculate each usage row’s cost before summing. Multiple sub-microdollar rows can therefore produce inconsistent totals, including disagreement between session totals and per-row breakdowns. Calculate and round each row’s microdollar cost before aggregation, then sum the results. Add a regression test covering multiple sub-microdollar rows.
PostgreSQL compatibility check omits required columns — internal/postgres/schema.go:2101
CheckSchemaCompat does not probe usage_events.cost_microdollars or the required model_pricing microdollar columns. An outdated or read-only schema may pass startup checks and later fail when usage endpoints query those columns. Include every newly required microdollar column in the compatibility probe.
Nullable API response conflicts with generated TypeScript type — internal/service/usage.go:350, frontend/src/lib/api/generated/models/ServiceUsagePairwiseComparisonDelta.ts:11
The Go API emits costPerSessionDelta: null when either period has zero sessions, but the generated TypeScript client declares the property as non-nullable MoneyMoney. Mark the money reference as nullable in the OpenAPI schema and regenerate the client so its type is MoneyMoney | null.

Reviewers: 2 done | Synthesis: codex, 11s | Total: 15m10s

Microdollars are the smallest representable monetary unit, so each deduplicated usage row must cross the pricing boundary independently. Aggregating tokens first could combine several sub-microdollar rows into a fabricated whole-microdollar cost that SQLite and PostgreSQL correctly omit. Keep DuckDB rows separate until exact integer pricing has produced whole microdollars, then aggregate only those representable values. Ratio-based allocation of an authoritative integer total remains separate and continues to apportion only whole microdollars.

roborev-ci · 2026-07-27T02:57:05Z

roborev: Combined Review (`b337f58`)

The change has four medium-severity correctness and performance issues that should be addressed before merging.

Medium

internal/postgres/schema.go:2100 — Incomplete PostgreSQL compatibility check

CheckSchemaCompat probes only usage_events.id, so pg serve may accept an older or partially migrated schema and later fail when usage queries reference cost_microdollars or microdollar pricing columns.

Fix: Probe every money column required by read paths, including legacy and partially migrated schema cases.
internal/db/money_migration.go:10 — Mixed SQLite schemas can discard authoritative values

The migration checks only for legacy columns. If both legacy and new money columns exist, it rebuilds from legacy data and may silently discard authoritative microdollar values.

Fix: Probe both legacy and final columns for every affected table and reject mixed or incomplete schemas before starting the transaction.
internal/export/pricing.go:30 — Pricing arithmetic can panic on overflow

CostForTokens panics on overflow, while custom pricing permits any nonnegative int64. A sufficiently large configured rate combined with a plausible token count can terminate CLI reports or abort HTTP responses.

Fix: Return and propagate arithmetic errors, or enforce bounds that guarantee permitted rates, token counts, and aggregated totals cannot overflow.
internal/duckdb/analytics_usage.go:4168 — Session counting adds cardinality-scaled query and memory work

GetUsageSessionCounts materializes every deduplicated usage row into a wide slice solely to count distinct sessions. GetDailyUsage already materializes the same rows and then calls this method, doubling row-scaled work for normal usage-page requests.

Fix: Use a dedicated streaming distinct-session query or collect session counts during the existing daily-row pass.

Reviewers: 2 done | Synthesis: codex, 12s | Total: 15m16s

Read-only PostgreSQL startup must reject legacy schemas before exact-money queries reach missing columns; otherwise a database can be declared compatible and fail only under usage traffic. The pairwise response legitimately omits a per-session delta when either side has no sessions, so publish that nullability in OpenAPI and keep the generated client aligned with runtime JSON.

roborev-ci · 2026-07-27T03:09:33Z

roborev: Combined Review (`1d56627`)

The microdollar migration has four medium-severity correctness issues; no security regressions were identified.

Medium

internal/export/pricing.go:45 — Checked monetary failures are converted into panics. Valid int64 rates or costs can overflow during pricing or aggregation, while callers also use MustAdd/MustSub; for example, current_microdollars=MinInt64 can panic the comparison endpoint.
- Fix: Propagate monetary errors through pricing and aggregation APIs, validate nonnegative request costs, and return an ordinary API/CLI error instead of panicking.
internal/parser/kilo_legacy.go:621 — Kilo costs are decoded and aggregated as float64 before conversion. This can alter nearest-microdollar rounding and allow a negative source charge to be hidden by positive charges.
- Fix: Preserve each JSON cost as json.Number, immediately parse and validate it as Money, and aggregate with checked integer addition.
internal/parser/hermes.go:1081 — An invalid, negative, non-finite, or overflowing Hermes cost makes hermesUsageEvents silently return no event, discarding otherwise valid token usage.
- Fix: Return and propagate the conversion error, or preserve the token event with an absent cost instead of dropping the entire usage row.
internal/db/cursor_usage_events.go:134 — Reconstructing legacy Cursor deduplication inputs from rounded microdollars changes the key when the original cent value had more than four fractional digits. After migration, refetching such an event can insert a duplicate and double-count usage.
- Fix: Preserve or generate the legacy deduplication key from the original decimal boundary value, or transactionally recompute migrated keys using the new quantized representation.

Reviewers: 2 done | Synthesis: codex, 13s | Total: 12m59s

Exact microdollars must fail closed when archive schemas are ambiguous or arithmetic exceeds the representable range. Reject mixed SQLite money columns before mutation, and return pricing failures through every backend instead of panicking in CLI or HTTP paths. Keep DuckDB row-level quantization without materializing the archive-sized usage stream, and derive daily session counts during that same pass. PostgreSQL compatibility now distinguishes an optional absent pricing table from inaccessible or incomplete exact-money columns.

roborev-ci · 2026-07-27T03:34:44Z

roborev: Combined Review (`d64ae29`)

The microdollar migration is broadly sound, but two medium-severity correctness issues remain in aggregation and legacy parsing.

Medium

Unchecked usage aggregation overflow — internal/db/usage.go:1958, internal/postgres/usage.go:1424, internal/duckdb/analytics_usage.go:3837

Usage aggregation still calls money.MustAdd. Individually valid costs can collectively exceed int64, causing the request path to panic rather than return an overflow error. Use checked money.Add, propagate contextual errors from GetDailyUsage, and add cross-backend overflow tests.
Inexact legacy Kilo cost aggregation — internal/parser/kilo_legacy.go:621

Legacy Kilo JSON costs are decoded and accumulated as float64, with conversion to Money only after summation. This can misround boundary totals and allow a negative component to be hidden by later positive costs. Decode each cost as json.Number, validate it immediately, and aggregate using exact decimal or checked Money arithmetic.

Reviewers: 2 done | Synthesis: codex, 10s | Total: 18m32s

Independent source rows must cross the whole-microdollar boundary before any aggregation; otherwise multiple unrepresentable fractions can fabricate stored cost. Keep ratio allocation limited to apportioning an authoritative integer total. Return arithmetic overflow through backend, activity, export, and HTTP paths instead of panicking. Preserve migrated Cursor identity after legacy values are quantized, and retain token events when only their reported cost is invalid.

roborev-ci · 2026-07-27T04:03:24Z

roborev: Combined Review (`0475b35`)

The migration has one medium-severity data-integrity issue that can double-count Cursor usage and cost.

Medium

internal/postgres/schema.go:435 — PostgreSQL converts fractional-cent Cursor charges to microdollars without recomputing dedup_key. SQLite rekeys these rows after quantization, so the next full-history PostgreSQL push sees a different key and inserts the same event again, double-counting usage and cost.

Fix: Recompute PostgreSQL Cursor dedup keys using post-quantization values during migration, resolve collisions before restoring the unique index, and add a migration test covering fractional cents followed by a repeated push.

Reviewers: 2 done | Synthesis: codex, 7s | Total: 18m3s

Quantizing legacy Cursor costs changes the only representable value that can participate in a stable fingerprint. Rekey both SQLite and PostgreSQL from that integer value so a full-history push cannot duplicate the same event across backends. Process migration keys in bounded batches, collapse quantization collisions deterministically, and keep valid Kilo token usage when only its reported cost is malformed.

Cursor fingerprints cross SQLite and PostgreSQL, so they cannot retain nanoseconds that PostgreSQL TIMESTAMPTZ cannot represent. Canonicalize to shared microsecond precision before hashing to prevent migration-and-push duplicates.

roborev-ci · 2026-07-27T04:37:14Z

roborev: Combined Review (`0e1e8fc`)

Monetary accounting migration looks sound overall, but two medium-severity gaps remain.

Medium

Concurrent PostgreSQL migration can fail — internal/postgres/schema.go:1023
Legacy money columns are inspected before the migration transaction without a cross-process lock. Two clients upgrading the shared schema concurrently can both observe the old columns; after one renames them, the other may execute DDL using stale names and fail startup or push. Acquire a schema-scoped advisory lock and re-read the column state while holding it before applying the transactional migration.
Artifact ledger still stores money as float64 — internal/artifact/wire.go:144
Artifact manifests continue to persist cost_usd as *float64, leaving an inexact machine-readable monetary boundary despite the authoritative Money contract. Introduce a new artifact format version using *money.Money, update the canonical golden test, and convert legacy v1 values only at the decoding boundary if compatibility is needed.

Reviewers: 2 done | Synthesis: codex, 8s | Total: 19m56s

Artifact manifests are a persistent machine-readable boundary and must not reintroduce floating-point dollars after the exact-money conversion. Encode Money directly while the format remains unreleased. Shared PostgreSQL schemas may be upgraded by multiple clients. Serialize the PR-local money migration per database and schema, then re-inspect columns under the lock so followers observe committed names instead of replaying stale DDL.

roborev-ci · 2026-07-27T04:59:45Z

roborev: Combined Review (`0aa65db`)

Medium — The monetary migration needs a manifest wire-version bump to prevent silent loss of authoritative usage costs.

Medium

internal/artifact/wire.go:37 — Manifest usage costs changed from numeric cost_usd values to cost objects, but the peer-facing, content-addressed wire format remains version 1. Old and new consumers can accept the same version while silently discarding the representation they do not recognize. Introduce a new manifest wire version and explicitly decode/migrate version-1 cost_usd manifests.

Reviewers: 2 done | Synthesis: codex, 7s | Total: 11m13s

Manifest usage costs changed from floating-point dollars to exact integer microdollars, so keeping the same wire version would let mixed-version peers silently ignore the authoritative representation. Version artifact kinds independently so this manifest-only change does not invalidate checkpoints, segments, or metadata.\n\nThe released artifact package has no production manifest producer or parser, so no v1 cost-bearing manifests can exist to migrate. Avoid adding an unreachable float compatibility path that would restore rounding at the money boundary.

roborev-ci · 2026-07-27T14:18:07Z

roborev: Combined Review (`57df394`)

No Medium, High, or Critical findings were reported.

Reviewers: 2 done | Synthesis: codex, 8s | Total: 17m22s

Main migrated ParsedUsageEvent.CostUSD to Cost *money.Money (authoritative microdollars, #1224) under this branch. Keep the wire-format float math for per-model apportionment and convert at the event boundary via omnigentCost, which drops unconvertible values (negative, non-finite) so catalog pricing applies, matching the parser's fail-soft posture.

Waypoint D of the staged upstream catch-up (specs/merge-upstream-waypoints.md). Merges u/main up to 8dc6adc (173 commits) — the money-as-authoritative- microdollars rewrite (new internal/money package; all cost/rate fields become money.Money int64 microdollars) plus a kit-ui bump, embeddings, and machine breakdowns. Pricing (convert the fork's 1h cache-write work to money, contract-preserving): - export.ModelRates.CacheWrite1hPerMTok is now money.Money (still internal: not in canonical_json / EffectiveModelRate, so the export wire stays byte-identical). - catalog.ModelPricing / db.ModelPricing gain a money.Money 1h field; the model_pricing column is cache_creation_1h_microdollars_per_mtok INTEGER alongside upstream's renamed microdollar columns; threaded through the batched upsert/insert/copy SQL, GetModelPricing, loadPricingMap, modelPricingRates, fallbackRateMap, customPricing, and pricingrefresh. - Fill1hCacheRate derives 1h from 5m in money terms as exactly 8/5 (multiply-by-8 then money.Divide by 5), replacing the float 2.0/1.25 ratio. - dailyUsageAmounts and sessionRowCost compute the 5m/1h split cost via money.CostPerMillion (5 RatedTokens) and savings via SignedCostPerMillion (read + 5m + 1h deltas), propagating money errors. - Bundled snapshot re-fetched in money format (SHA-pinned artifact); 1h derived at load. usage projects CLI cost is money.Money. Subagent rollup: rollupProjectExpr re-injected into all four daily-usage templates (upstream added an s.machine column). Artifact ledger: manifestSession gains a private field to stay byte-identical with db.Session (fork's private column); canonical-manifest golden updated. Frontend: adopted upstream's kit-ui CSS-var palette + hashColor + seriesColorMap (its collision-relief supersedes the fork's 24-color golden-angle palette and disambiguateColors), keeping the fork's org-theming (setOrgTheme) on top; AttributionPanel/costs read money via .microdollars; forced a kit-ui refetch to the pinned SHA (Card/Toggle/Checkbox). Deferred (unchanged): 1h-cache parity for the PostgreSQL and DuckDB cost paths. Green: go build/vet, all money/pricing/db/export/service/snapshot/artifact tests, svelte-check, make build. (Environmental: the snapshot test needing a git `origin` remote; one flaky sync concurrency-bound test that passes on re-run.) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

github-advanced-security AI found potential problems Jul 22, 2026

View reviewed changes

Comment thread internal/money/decimal.go Fixed

Comment thread internal/money/decimal.go Fixed

mariusvniekerk force-pushed the feat/authoritative-microdollars branch from dcc0736 to 6e08b51 Compare July 25, 2026 02:13

mariusvniekerk added 8 commits July 26, 2026 22:18

mariusvniekerk force-pushed the feat/authoritative-microdollars branch from e9071b0 to 93e685b Compare July 27, 2026 02:20

mariusvniekerk added 2 commits July 27, 2026 00:06

fix(money): canonicalize cursor timestamps

0e1e8fc

Cursor fingerprints cross SQLite and PostgreSQL, so they cannot retain nanoseconds that PostgreSQL TIMESTAMPTZ cannot represent. Canonicalize to shared microsecond precision before hashing to prevent migration-and-push duplicates.

mariusvniekerk marked this pull request as ready for review July 27, 2026 15:05

mariusvniekerk merged commit 8dc6adc into main Jul 27, 2026
23 checks passed

mariusvniekerk deleted the feat/authoritative-microdollars branch July 27, 2026 15:06

Uh oh!

Conversation

mariusvniekerk commented Jul 22, 2026

Uh oh!

Uh oh!

Uh oh!

roborev-ci Bot commented Jul 22, 2026

roborev: Combined Review (dcc0736)

High

Medium

Uh oh!

roborev-ci Bot commented Jul 24, 2026

roborev: Combined Review (dcc0736)

High

Medium

Uh oh!

roborev-ci Bot commented Jul 25, 2026

roborev: Combined Review (6e08b51)

Medium

Uh oh!

roborev-ci Bot commented Jul 25, 2026

roborev: Combined Review (e9071b0)

High

Medium

Uh oh!

roborev-ci Bot commented Jul 27, 2026

roborev: Combined Review (93e685b)

Medium

Uh oh!

roborev-ci Bot commented Jul 27, 2026

roborev: Combined Review (b337f58)

Medium

Uh oh!

roborev-ci Bot commented Jul 27, 2026

roborev: Combined Review (1d56627)

Medium

Uh oh!

roborev-ci Bot commented Jul 27, 2026

roborev: Combined Review (d64ae29)

Medium

Uh oh!

roborev-ci Bot commented Jul 27, 2026

roborev: Combined Review (0475b35)

Medium

Uh oh!

roborev-ci Bot commented Jul 27, 2026

roborev: Combined Review (0e1e8fc)

Medium

Uh oh!

roborev-ci Bot commented Jul 27, 2026

roborev: Combined Review (0aa65db)

Medium

Uh oh!

roborev-ci Bot commented Jul 27, 2026

roborev: Combined Review (57df394)

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Milestone

Development

Uh oh!

2 participants

roborev: Combined Review (`dcc0736`)

roborev: Combined Review (`dcc0736`)

roborev: Combined Review (`6e08b51`)

roborev: Combined Review (`e9071b0`)

roborev: Combined Review (`93e685b`)

roborev: Combined Review (`b337f58`)

roborev: Combined Review (`1d56627`)

roborev: Combined Review (`d64ae29`)

roborev: Combined Review (`0475b35`)

roborev: Combined Review (`0e1e8fc`)

roborev: Combined Review (`0aa65db`)

roborev: Combined Review (`57df394`)