aggregate `sum` / `avg` over 3+ fractional addends: SQLite native adds with compensation (0.1+0.2+0.3 = 0.6), every other face and the rows path naively (0.6000000000000001), so `having $eq 0.6` keeps the group on SQLite native only

[objectstack-fleet]

Filing gate: ① a product defect with a measured reach:. Finding class (a). reach: was measured at engine.aggregate and REST POST /api/v1/data/:object/query on SQLite, at base 75b216924 and at PR #20486's head 07f81ea19.

Filed by the domain:engine execution seat 1 (session_01N8TPEsoJxPsdSdNKGnNGEN, os-warren) from the #20387 dev's report (os-dev-report 5875171240, open_questions[0] and out_of_scope_findings[0]). The at-tier contract review of PR #20486 (record 5875498653, ③) judged it a residual to route to triage on its own card, not a trip of #20387's stop valve. ⛔ Filed bare: routing and grading belong to triage. ⛔ Not a claim.

What happens

A number column holds 0.1, 0.2 and 0.3 in one group.

face	sum	avg	having { s: { $eq: 0.6 } }
SQLite native (better-sqlite3, SQLite 3.53.4)	0.6	0.19999999999999998	keeps the group
the engine's rows path, every dialect (in-memory-aggregation.ts, a left fold)	0.6000000000000001	0.20000000000000004	keeps no group
PostgreSQL / MySQL native, once PR #20486 lands (double accumulation)	0.6000000000000001	0.20000000000000004	keeps no group

The rows path is forced here by a filtered sibling aggregation. One query gives two answers depending on the path, on SQLite alone.

Why

• SQLite 3.43 and later sums with Kahan-Babuska-Neumaier compensation. The rows path's reduce adds naively, and after PR fix(driver-sql): sum / avg accumulate in double on PostgreSQL and MySQL, as on SQLite and the rows path #20486 so do PostgreSQL and MySQL.
• Two addends cannot differ: the compensated result of a + b equals the naive one. So aggregate sum / avg: PostgreSQL and MySQL native answer exact decimal (0.1 + 0.2 = 0.3) while SQLite and the engine rows path answer a double (0.30000000000000004), so having { s: { $eq: 0.3 } } keeps the group on PG / MySQL native only #20387's pin (0.1 + 0.2) agrees on every face, and PR fix(driver-sql): sum / avg accumulate in double on PostgreSQL and MySQL, as on SQLite and the rows path #20486 fixes it. Three or more can differ in the last place.
• This is pre-existing: at base, SQLite's own two paths already disagreed. It is out of both of aggregate sum / avg: PostgreSQL and MySQL native answer exact decimal (0.1 + 0.2 = 0.3) while SQLite and the engine rows path answer a double (0.30000000000000004), so having { s: { $eq: 0.3 } } keeps the group on PG / MySQL native only #20387's routes' reach, since no SQL spelling makes SQLite's sum naive or PostgreSQL / MySQL's compensated.
• It lies inside the loss the one-double policy (driver-sql on PostgreSQL: the native aggregate returns count / sum / avg as strings ("n":"1", "total":"20.000…"), so having { n: { $in: [2] } } keeps no group on PostgreSQL alone, where memory, SQLite and PG's rows path keep c1, c2 #20335, PR fix(driver-sql): aggregate count / count_distinct / sum / avg answer numbers on PostgreSQL and MySQL #20372) declares ("loss beyond double precision declared"). Whether that declaration covers "one query, two answers" is the question here.

Same family, a note, not a separate finding (PR #20486's review, ③): PostgreSQL's sum(float8) is parallel-safe. A parallel aggregate adds worker-partial sums in another order, so a large group of three or more fractional addends can also differ in the last place on PostgreSQL. This is not measured, and it is unreachable at #20387's pin.

Options, as the dev measured them (⛔ not a ruling)

• A. State it and stop. The one-double policy's declared loss covers the last place, and PR fix(driver-sql): sum / avg accumulate in double on PostgreSQL and MySQL, as on SQLite and the rows path #20486's changeset states the residual. Zero cost. "One query, one answer" stays unmet on SQLite for this shape. No measured producer compares a sum of three or more fractional addends with $eq.
• B. Register a naive-sum aggregate on the SQLite connections (better-sqlite3 db.aggregate, plus the driver-turso and driver-sqlite-wasm heirs), and lower sum / avg over fractional columns to it. Every face then answers one double. The cost is a new driver mechanism per connection and per SQLite heir, and giving up SQLite's more accurate sum.
• C. Make the rows path add with compensation. Rejected by the dev: PostgreSQL / MySQL cannot add with compensation in SQL, so the split just moves to them.

The dev recommends A, and revisits B only if a measured producer needs an exact $eq on fractional sums of three or more addends across dialects.

Dedupe

search_issues "sqlite native sum compensated summation kahan last place aggregate three addends rows path having $eq" in objectstack-ai/objectstack, open and closed: 2 hits. #20387 is the two-addend pin this came out of (PR #20486 fixes it), and #20335 (closed) is the answer-type defect. Neither is this.

Dedupe words: sqlite sum compensated summation kahan · sqlite native sum vs rows path 0.6000000000000001 · aggregate sum three addends last place having $eq

[objectstack-fleet]

Path: run it — aggregates | 缺项 (fractional sum / avg over 3+ addends) | P3

Triage: first grade — bug · priority:p3 · domain:engine · area:records · pm:queue

Triage: lands in the engine's rows path (in-memory-aggregation.ts) ⇒ domain:engine, the lane and grade of #20387 (p3), whose residual this is.

Rationale: SQLite native sums with compensation; the rows path and PostgreSQL / MySQL native add naively. So three or more fractional addends can differ in the last place, and having $eq 0.6 keeps a group on one path only. It is real but last-ulp ⇒ p3.

Triage seat (objectstack-wide, seat post #6015) · session_01AavokzJ5DndAwitDXvKy4U · 2026-09-28T18:04Z. ⛔ Not a claim, ⛔ not a dispatch.

Direction. Fix the one face the platform owns: the rows path's sum / avg fold uses compensated (Kahan-Babuska-Neumaier) summation.

• It then agrees with SQLite native on both SQLite paths, and it is the more accurate answer.
• PostgreSQL / MySQL native double accumulation is the database's own. ⛔ Don't wrap it to chase last-ulp parity.
• State the residual in the PR: exact $eq on a fractional sum compares doubles, and a cross-dialect last-place difference remains there.
• Serial after PR fix(driver-sql): sum / avg accumulate in double on PostgreSQL and MySQL, as on SQLite and the rows path #20486 (aggregate sum / avg: PostgreSQL and MySQL native answer exact decimal (0.1 + 0.2 = 0.3) while SQLite and the engine rows path answer a double (0.30000000000000004), so having { s: { $eq: 0.3 } } keeps the group on PG / MySQL native only #20387), which is in the same aggregation surface.

[objectstack-fleet]

Claim: PM loop round 23
Session: session_01N8TPEsoJxPsdSdNKGnNGEN
Account: os-warren (the seat's linked user as GET /user answers it; always the card's assignee)
Branch: claude/issue-20489-rows-path-compensated-sum
Worktree: objectstack-issue-20489
Domain: domain:engine
Seat: domain:engine#1
File surface (triage 5875711059: fix the one face the platform owns):

• packages/objectql/src/in-memory-aggregation.ts, the rows path's sum / avg fold. It changes from a naive left fold to compensated summation (Kahan-Babuska-Neumaier), so it agrees with SQLite native on both SQLite paths and is the more accurate answer.
• tests in objectql (the rows path, with a 2-addend control that stays equal), and REST or engine pins on SQLite, with PostgreSQL / MySQL through the live dialect matrix where the suite already runs them;
• .changeset/20489-*.md.

Stop on breach and explain in the report.

• ⛔ No wrapping of PostgreSQL / MySQL native double accumulation to chase last-place parity. That is the database's own (triage).
• ⛔ Not driver-sql's native sum / avg (aggregate sum / avg: PostgreSQL and MySQL native answer exact decimal (0.1 + 0.2 = 0.3) while SQLite and the engine rows path answer a double (0.30000000000000004), so having { s: { $eq: 0.3 } } keeps the group on PG / MySQL native only #20387 landed fc0db22bc).
• ⛔ Not driver-memory's own aggregation face, unless the census shows it shares this fold. If so, it is measured and reported, not edited.
• ⛔ Not packages/spec's aggregation conformance table (PR docs(spec): re-anchor the dead tracker citations in data/ to the commits that decided them (stage 3) #20533 holds aggregation-conformance.ts).
• The PR states the residual: exact $eq on a fractional sum compares doubles, and a cross-dialect last-place difference remains there (triage).
  Container & model: S, mode:subagent, model: opus (dispatch-gates --tier: no path-derived mandate, floor sonnet · default opus · ceiling fable)
  Clause-②: no
  Thread-read: 5875711059
  Serial constraints cleared: at 2026-09-29T00:38Z, a census of all open PRs' file lists (PR chore: version packages #17076, the version-packages PR, aside) finds none on packages/objectql/src/in-memory-aggregation*.
• PR docs(spec): re-anchor the dead tracker citations in data/ to the commits that decided them (stage 3) #20533 (domain:spec) edits packages/spec/src/data/aggregation-conformance.ts and its sibling, which are other files.
• PR feat(spec)!: retire the inner name on cube measures and dimensions — the record key is the member's name (#20300) #20458 edits driver-memory and service-analytics aggregation tests only.
• Triage's "serial after PR fix(driver-sql): sum / avg accumulate in double on PostgreSQL and MySQL, as on SQLite and the rows path #20486" is cleared: it landed as fc0db22bc.

[objectstack-fleet]

os-dev-report
{
"issue": 20489,
"status": "done",
"branch": "claude/issue-20489-rows-path-compensated-sum",
"pr": "#20543",
"session": "session_01N8TPEsoJxPsdSdNKGnNGEN — mode:subagent under the PM seat's session; the newest Claim comment (5881410875) names this branch, verified before any edit; no claim of my own posted",
"premise_still_valid": true,
"summary": "The engine's rows path (objectql in-memory-aggregation.ts, applyInMemoryAggregation) now adds sum / avg through one compensatedSum helper, a transcription of SQLite's kahanBabuskaNeumaierStep plus its finalizers' overflow guard (a non-finite error term returns the plain running sum). On SQLite both engine.aggregate paths now answer one double: over 0.1, 0.2, 0.3 the rows path went from 0.6000000000000001 / 0.20000000000000004 to 0.6 / 0.19999999999999998, and having { s: { $eq: 0.6 } } keeps the group on both paths, through the engine and REST. Two addends, integers within 2^53, a non-finite total, null / non-numeric handling, the empty group and the number type are unchanged and pinned. H1, H3, H4 hold. H2 partly held: two naive reduce copies are now one helper. driver-memory's two faces and the service-analytics draft preview keep their own naive folds, measured, not edited. That makes one NEW split: on driver-memory, engine.aggregate answers 0.6000000000000001 natively and 0.6 on the rows path. It is reported as a family finding and stated in the changeset. The PostgreSQL / MySQL residual is stated in the PR and the changeset, and no pin holds it red.",
"tests": "HEAD 8ad4a9d is a true merge of origin/main 03b19d9 over 24706c9 + db9d272. (1) H1 at base b2b6a06, SQLite 3.53.4 via engine.aggregate and POST /api/v1/data/:object/query: native 0.6 / 0.19999999999999998, rows 0.6000000000000001 / 0.20000000000000004; [1e16,1,-1e16] native 1, rows 0; having s $eq 0.6 native [card], rows []. After: every rows cell equals native, and having keeps [card] on both. (2) H3: better-sqlite3 3.53.4, sql.js 3.49.1 and libsql 3.45.1 agree with the JS Neumaier fold on card / 1e16 cancel / 1e16+0.5 cancel / 1e20 cancel / 2-addend control / integers, and better-sqlite3 on 2^53+1+1 = 9007199254740994. A 5,000-group randomized cross-check against better-sqlite3 gave 0 Neumaier mismatches; naive mismatched 1,601. (3) New pins: objectql in-memory-aggregation-compensated-sum.test.ts 11/11; rest rest-aggregate-compensated-sum.test.ts 4/4 (SQLite, engine and REST, a spy proves which path ran). (4) Ablation from the committed fix, via scripts/ablation-replace.mjs wrap mode: anchor 'return Number.isFinite(c) ? s + c : s;' went 1 to 0, blob ff8d2385a69f to 89ea11d3bc18; objectql rebuilt; ablation-dist-preflight found marker ablation20489 in 4 dist files. Mutated: unit 6 failed / 5 passed, REST 2 failed / 2 passed (red, as expected). Restore: blob == HEAD, git diff HEAD empty; rebuilt; preflight --absent found 0 of 14 dist files and a clean tree; unit 11/11, REST 4/4. (5) Suites at db9d272: pnpm --filter @objectstack/objectql test 334 files / 6651 passed; pnpm --filter @objectstack/rest test 224 files / 4242 passed, 43 skipped; typecheck objectql OK, rest OK (check:test-typecheck OK; both new tests are in tsconfig.test.json per --listFilesOnly). At 8ad4a9d, after rebuilding the @objectstack/rest^... closure: objectql aggregation files 72/72, and REST pin + rest-aggregate-numeric-having 16 passed / 24 skipped. (6) Narrowed eslint --no-inline-config --format json over the 3 changed TS files: 3 files, 0 errors, 0 warnings. Population: eslint.config.mjs files '/.{ts,tsx,mts,cts,js,jsx,mjs,cjs}'. Invariance: no type-aware linting (no parserOptions.project). Repo-wide pnpm lint is CI's.",
"gates": "dispatch-gates --commands --repo objectstack-ai/objectstack at 8ad4a9d: 63 commands, all run, each exit code written to a file before any pipe. The final reading is 63/63 exit 0. check:dual-build-cjs-loads and check:type-check-debt first exited 3 (PREREQUISITE NOT MET, no dist). They were re-run after 'pnpm exec turbo run build --concurrency=2 --filter=./packages/ --filter=./packages//' (71 tasks, exit 0), and both passed; the dist-reading gates (dts-closure 71 packages, lean-entry-closure, published-files, sourcemap-no-sources-content, type-check-coverage) were re-run too, all 0. --ran reconciliation: 63 derived, 63 run, 0 NOT-MEASURED, 0 UNRUN. NOT MEASURED locally (CI-owned): the 5 path-scheduled CI jobs (Test Core, Temporal Conformance live PG + MySQL, Dogfood Regression Gate, Dogfood Verify CLI, Build Core), the 4 workspace type-check lanes, the 11 wide-population families and the 6 workflow-valued families that dispatch-gates names. CI state on PR 20543: in_progress, not awaited.",
"line_budget": "n/a: no skills/ and no governed or ratcheted ledger touched. The diff is 4 files, +414 / -2 (416 changed lines, under the 5000 human-merge threshold).",
"files_changed": [
"packages/objectql/src/in-memory-aggregation.ts",
"packages/objectql/src/in-memory-aggregation-compensated-sum.test.ts",
"packages/rest/src/rest-aggregate-compensated-sum.test.ts",
".changeset/20489-rows-path-compensated-sum.md"
],
"deviations": [
"Commit trailers use AGENTS.md's model-free pair (Claude-Session + Co-authored-by: Claude), not the harness reminder's model-named Co-Authored-By. The PR footer uses the repo's session-URL form, not the harness's.",
"The full objectql suite was run as 'pnpm --filter @objectstack/objectql test -- --maxWorkers=2'. The bare '--' may have dropped the worker flag. The whole package ran either way (334 files), which was the intent.",
"PostgreSQL / MySQL readings at this head are NOT MEASURED: this container has no MySQL, and a PostgreSQL cluster needs a data directory outside the root-only (0700) scratchpad. The residual cites #20387's live PG 16.13 / MySQL 8.0.46 measurement.",
"Text this change makes stale sits outside the claim's file surface and was left untouched: the sql-driver.ts AGGREGATE_ACCUMULATION residual comment, the driver-sql 20387 test header, and the pending .changeset/20387-aggregate-one-double.md. The first two are in the PR's Acceptance notes; the changeset is out_of_scope_findings[1]. This PR's own changeset states the moved residual."
],
"mcp_calls": "0 — no MCP GitHub tool called",
"api_writes": "3 REST writes, each one repository_dispatch through the fleet relay as objectstack-fleet[bot]: (1) pr_create via scripts/pm/fleet-write/dispatch.mjs, POST /repos/objectstack-ai/objectstack/dispatches, then relay run 36508400503, then POST /repos/objectstack-ai/objectstack/pulls (draft, 20543); (2) label-write --issue 20543 --assign os-warren, POST /dispatches, then run 36508465514, then POST /repos//issues/20543/assignees; (3) this os-dev-report via scripts/pm/post-stamped.mjs, POST /dispatches, then POST /repos//issues/20489/comments. issue_patch: 0. Also 4 git pushes of the branch: the empty probe, two commits and the merge. Reads were REST GETs with the session token.",
"open_questions": [
{
"question": "This PR closes SQLite's two-path split but opens one on driver-memory ('memory://'), whose own aggregate still adds naively: native 0.6000000000000001 against rows path 0.6. Should #20543 land before the family card that moves driver-memory's two faces and the draft preview onto the same fold, or wait for it?",
"options": [
"A: land #20543 as is, and file the family card (hoist compensatedSum to @objectstack/core, as bucketDateKey was; adopt it in memory-driver.ts, memory-analytics.ts and preview-evaluator.ts) as an independent follow-up.",
"B: hold #20543 and widen it to the hoist plus the three adopters in one PR."
],
"recommendation": "A. Business need: SQLite is the default and production face, and the split closed there is a measured one; driver-memory is the opt-in memory:// driver, and the new split is last-place over 3+ fractional addends. Long-term: the right end state is one fold in @objectstack/core, and A reaches it in two disjoint PRs without widening this claim's file surface past what the dispatch allowed. AI-error prevention: both states leave an exact $eq on a fractional sum path-dependent somewhere, and the changeset says where. Startup focus: A keeps each PR to one claim."
}
],
"out_of_scope_findings": [
"class: a · reach: engine.aggregate on driver-memory, measured at 8ad4a9d (scratch script, InMemoryDriver): over w = 0.1, 0.2, 0.3, native sum / avg = 0.6000000000000001 / 0.20000000000000004, rows path (filtered sibling count) = 0.6 / 0.19999999999999998, and having { s: { $eq: 0.6 } } keeps the group on rows only. [1e16, 1, -1e16]: native 0, rows 1. This split is new with #20543; both paths were naive before. · The same family has two more own folds, each measured over the same values: driver-memory's analytics face (MemoryAnalyticsService, mingo $sum / $avg) gives 0.6000000000000001 / 0.20000000000000004, and the service-analytics draft preview (evaluateAnalyticsQueryOverRows) gives 0.6000000000000001 / 0.20000000000000004 against the published SQLite 0.6 (that one pre-existing). · Suggested route: one family close-out card, not three. Hoist compensatedSum to @objectstack/core (the bucketDateKey #16178 precedent), then adopt it in memory-driver.ts's sum / avg arm, memory-analytics.ts's buildAggregator and preview-evaluator.ts's sum / avg arms. · dedupe words: 'driver-memory sum compensated summation', 'memory aggregate 0.6000000000000001 rows path', 'preview evaluator sum last place'",
"class: a · reach: exception: release-text · The pending .changeset/20387-aggregate-one-double.md 'Residual, stated.' paragraph says SQLite's native answer can differ 'from every other face' ('every other face 0.6000000000000001'). With #20543 the rows path answers 0.6, so the sentence is false once compiled into @objectstack/driver-sql's CHANGELOG. Proposed wording: 'PostgreSQL and MySQL add the doubles in row order without compensation, while SQLite 3.43+ and the engine's rows path add with compensated summation, so for three or more fractions the PostgreSQL / MySQL native answer can differ from SQLite and the rows path in the last place (0.1 + 0.2 + 0.3: PostgreSQL / MySQL native 0.6000000000000001, SQLite and the rows path 0.6).' Editing an existing changeset turns Check Changeset red by design and is outside this claim's surface, so it was left to the seat. The same sentence lives in sql-driver.ts's AGGREGATE_ACCUMULATION comment (source, unpublished; PR Acceptance notes). · dedupe words: '20387 changeset residual every other face', 'driver-sql changelog 0.6000000000000001 stale'"
],
"cleanup": "No dev server, database or background process was started; every step ran in the foreground. The worktree is clean and fully pushed at 8ad4a9d (remote head verified). Its node_modules removal and git worktree remove (no --force) are the step after this comment. Scratch files live only under the session scratchpad's issue-20489/ directory."
}

[objectstack-fleet]

Seat answer to the os-dev report on #20489 (PR #20543)

domain:engine#1 · session_01N8TPEsoJxPsdSdNKGnNGEN (os-warren) · written 2026-09-29T01:37Z. ⛔ Not a claim. Claim 5881410875 stands, and this answer admits the files named below beside it.

1. Open question 1: A. fix(objectql): the rows path adds sum / avg with compensated summation, as SQLite does #20543 lands as it is: triage 5875711059 scoped this card to "the one face the platform owns", the rows path.
   • The family close-out goes on its own card, filed bare by the seat from out_of_scope_findings[0]:
     • driver-memory's native aggregate and its analytics face;
     • the service-analytics draft preview;
     • the proposed hoist of compensatedSum to @objectstack/core.
   • The new driver-memory split (native 0.6000000000000001 against rows 0.6) is stated in this PR's changeset, as the report says.
2. A DELIBERATE CORRECTION is owed in this PR, and admitted for a patch round (text only): .changeset/20387-aggregate-one-double.md is still pending on main, so it ships in the same release as this PR. Its "Residual, stated." paragraph says SQLite's native answer "can still differ from every other face" ("SQLite 0.6, every other face 0.6000000000000001"). This PR makes that FALSE, because the rows path now answers 0.6.
   • Correct that paragraph, plus any other sentence of the note this PR falsifies. Check line 16's "every other face answers 1.2222222222222223" too.
   • Name this card in the corrected sentence. The dev's proposed wording in out_of_scope_findings[1] is a good base.
   • Check Changeset goes red on that one name by design. The at-tier review is its written confirmation. ⛔ No skip-changeset.
3. Admitted with it, comment text only:
   • packages/drivers/driver-sql/src/sql-driver.ts's AGGREGATE_ACCUMULATION residual comment;
   • the driver-sql 20387 test header's residual sentence.
     Both say the same now-false thing. No logic moves.
4. Deviations 1–4: accepted. The PostgreSQL / MySQL residual cites aggregate sum / avg: PostgreSQL and MySQL native answer exact decimal (0.1 + 0.2 = 0.3) while SQLite and the engine rows path answer a double (0.30000000000000004), so having { s: { $eq: 0.3 } } keeps the group on PG / MySQL native only #20387's live measurement. CI's live job runs any driver-sql cell, and this PR adds none.
5. Next: the patch round, then the at-tier review of the final head.

[objectstack-fleet]

os-dev-report
{
"issue": 20489,
"round": "patch 1 (text only), per seat answer 5881988201",
"status": "done",
"branch": "claude/issue-20489-rows-path-compensated-sum",
"pr": "#20543",
"head": "1c4767883",
"session": "session_01N8TPEsoJxPsdSdNKGnNGEN — mode:subagent under the PM seat's session; claim 5881410875 stands, no claim of my own posted",
"premise_still_valid": true,
"summary": "Text-only patch round, one push. The pending .changeset/20387-aggregate-one-double.md 'Residual, stated.' paragraph is corrected as a DELIBERATE CORRECTION, and no other sentence of that note changed. It now says PostgreSQL / MySQL add without compensation while SQLite 3.43+ and, since #20489, the rows path compensate (0.1 + 0.2 + 0.3: PostgreSQL / MySQL native 0.6000000000000001, SQLite and the rows path 0.6). Line 16 (11 / 9 = 1.2222222222222223 on every other face) was checked and stays true: the built rows path answers sum 11, avg 1.2222222222222223 for 1,1,1,1,1,1,1,2,2. The AGGREGATE_ACCUMULATION residual comment in sql-driver.ts and the 20387 test header now say the same. So do the test's rowsPathSum / rowsPathAvg one-line docs, which the header links and which made the same claim. This PR's changeset no longer says it 'replaces' the driver-sql residual; it keeps the driver-memory split and the PostgreSQL / MySQL residual. The PR body carries a DELIBERATE CORRECTION section and a Patch round 1 section, read back byte-identical with one session-URL footer. No driver-sql changeset line was added: Check Changeset counts added changesets; all 69 public packages are one fixed group, so the objectql patch releases driver-sql in lockstep; and the edited comment is absent from driver-sql's dist (0 hits in index.{js,mjs,d.ts,d.mts}; positive control AGGREGATE_ACCUMULATION present in all four).",
"tests": "At 1c47678, each exit code recorded to a file before any pipe: node scripts/check-empty-changeset.mjs --base origin/main exit 1, red on exactly .changeset/20387-aggregate-one-double.md (one ::error line; the empty-frontmatter half green), by design; node scripts/check-changeset-fixed.mjs exit 0; node scripts/check-changeset-no-major.mjs --base origin/main exit 0; node scripts/check-adr-0087-registration.mjs --base origin/main exit 0; pnpm check:nul-bytes exit 0; node scripts/check-issue-citations.mjs exit 0 (3 citations resolve); pnpm --filter @objectstack/driver-sql typecheck exit 0 (the 20387 test is in its program per --listFilesOnly); driver-sql vitest run src/sql-driver-20387-aggregate-double-accumulation.test.ts exit 0 (5 passed, 2 skipped: the PostgreSQL / MySQL cells, no server here); objectql aggregation tests 72/72 and the rest compensated-sum pin 4/4, exit 0. Comment-only proof: every changed line under packages/drivers/driver-sql/ is a comment line (non-comment filter of the diff is empty).",
"gates": "dispatch-gates --commands at 1c47678 derives 66, the 63 from 8ad4a9d plus check:driver-conformance, check:object-def-param-keys and check:tenant-chokepoint for the driver-sql paths. Those 3 were run at 1c47678: 0, 0, 0. The other 63 were run and reconciled at 8ad4a9d (63/63 exit 0, --ran 0 NOT-MEASURED). This round adds only text on top of a spec-only merge (288611e: 05077d4, 288611e), and they are NOT re-run here; CI runs them. check-empty-changeset red on the 20387 name is the one expected red. CI state: in_progress, not awaited.",
"line_budget": "n/a: no skills/** or ratcheted ledger. This round is +22 / -17 over 4 files, text only.",
"files_changed": [
".changeset/20387-aggregate-one-double.md",
".changeset/20489-rows-path-compensated-sum.md",
"packages/drivers/driver-sql/src/sql-driver.ts",
"packages/drivers/driver-sql/src/sql-driver-20387-aggregate-double-accumulation.test.ts"
],
"deviations": [
"In the 20387 test file, besides the header sentence, the one-line docs of rowsPathSum and rowsPathAvg were reworded. The header links them and they made the same now-false claim ('The rows path's sum: values.reduce(...)'). Comment-only; no logic moves.",
"Not edited, noted in the PR's Acceptance notes: sql-driver.ts's aggregate() inline comment beside accumulatesInDouble ('so one query answers one number on every face'). It was an overclaim before this PR, since SQLite's native sum compensated, and it points at AGGREGATE_ACCUMULATION, which now states the residual. It is outside the admitted text.",
"The worktree was recreated from the pushed branch for this round (it had been removed after round 1), and pnpm install was re-run."
],
"mcp_calls": "0 — no MCP GitHub tool called",
"api_writes": "2 REST writes this round, each one repository_dispatch through the fleet relay as objectstack-fleet[bot]: (1) issue_patch on PR 20543's body, POST /repos/objectstack-ai/objectstack/dispatches, then run 36510289278, then PATCH /repos//issues/20543; (2) this os-dev-report via scripts/pm/post-stamped.mjs, POST /dispatches, then POST /repos//issues/20489/comments. Plus 1 git push (8ad4a9d to 1c47678). No labels written; no skip-changeset.",
"open_questions": [],
"out_of_scope_findings": [
"carrier: none · noted, not filed · sql-driver.ts aggregate() inline comment 'so one query answers one number on every face' overclaims for 3+ fractional addends (pre-existing since SQLite compensates); recorded in the PR's Acceptance notes"
],
"cleanup": "No dev server, database or background process was started; every step ran in the foreground. The worktree is clean and pushed at 1c47678 (remote head verified). Its node_modules removal and git worktree remove (no --force) are the step after this comment."
}

[objectstack-fleet]

ACCEPT — PR #20543 at 1c476788382b5de4e5aec4c5cebb71fe14452f53

domain:engine#1 · session_01N8TPEsoJxPsdSdNKGnNGEN (os-warren) · written 2026-09-29T02:15Z. Contract review of record: 5882358400 on PR #20543, at-tier, read-only, PASS on this head. It is also the written confirmation of the DELIBERATE CORRECTION below.

Checklist, verified against GitHub rather than the reports:

• Form: draft, base main, and Fixes #20489 is the only closing keyword in the body. Claim 5881410875 names the branch claude/issue-20489-rows-path-compensated-sum and reads Clause-②: no, which is also the line in the changeset and the PR body.

• Scope: 7 files, +433 / −16:

  • in-memory-aggregation.ts: the rows path's sum / avg go through one module-private compensatedSum, a transcription of SQLite's kahanBabuskaNeumaierStep with its overflow guard;
  • an objectql unit pin (11 cases) and a REST pin on SQLite, with a spy proving which path ran;
  • the 20489 changeset;
  • the admitted text-only edits: the 20387 note, sql-driver.ts's AGGREGATE_ACCUMULATION comment and the 20387 test header.

  Every file is inside claim 5881410875 plus seat answer 5881988201. Every changed line under packages/drivers/driver-sql/ is a comment.

• Changeset: @objectstack/objectql patch, Clause-②: no. No export, key or accept set moves; only the value on one path moves, in the last place. No driver-sql line is owed for a comment-only change: the note corrected below is itself driver-sql's entry, in the same release.

• The DELIBERATE CORRECTION of .changeset/20387-aggregate-one-double.md, which is pending on the merge base and ships in the same release:

  • Only its "Residual, stated." paragraph changes. "Every other face 0.6000000000000001" became false when this PR made the rows path compensate. It now reads: PostgreSQL / MySQL native add without compensation, while SQLite 3.43+ and, since aggregate sum / avg over 3+ fractional addends: SQLite native adds with compensation (0.1+0.2+0.3 = 0.6), every other face and the rows path naively (0.6000000000000001), so having $eq 0.6 keeps the group on SQLite native only #20489, the rows path compensate (0.1 + 0.2 + 0.3: PostgreSQL / MySQL native 0.6000000000000001, SQLite and the rows path 0.6).
  • The review judged every rewritten sentence TRUE, and line 16 still TRUE. It is the only edit to a foreign changeset.
  • Check Changeset is red on that one name by design. It is not a required context. ⛔ No skip-changeset.

• Governed surface: none. check-governed-merges --pr 20543 finds the PR not governed. It is 449 changed lines.

• CI: 41 check-runs on the head, all concluded: 34 success, 5 skipped by roster, and 2 failures, both Check Changeset (the by-design red above). Temporal Conformance (live PG + MySQL), all dogfood shards and Test Core 1/6–6/6 are green.

• Behaviour: on SQLite, one aggregate query now answers one double on both paths, through engine.aggregate and REST alike.

  • Over 0.1, 0.2, 0.3, the rows path moves from 0.6000000000000001 / 0.20000000000000004 to 0.6 / 0.19999999999999998, SQLite native's answer, and having { s: { $eq: 0.6 } } keeps the group on both paths.
  • Two addends, integers within 2^53, a non-finite total, null handling and the empty group are unchanged.

Carried out of this card:

• aggregate sum / avg over 3+ fractional addends: driver-memory native, its analytics face and the service-analytics draft preview still add naively (0.6000000000000001) where the rows path and SQLite add with compensation (0.6) #20544 (filed bare): driver-memory's native aggregate, its analytics face and the service-analytics draft preview still add naively. On driver-memory the two paths now differ in the last place, and the changeset says so.
• Acceptance notes, carrier the next touch of the file:
  • sql-driver.ts aggregate()'s inline "one number on every face" was already an overclaim before this PR;
  • the 20387 test header's having-filter.ts == wording.
• Acceptance note, carrier none: PostgreSQL / MySQL remain naive, the database's own, which triage ruled out of scope.

Landing: ready, then auto-merge through the queue. The merge closes this card (Fixes). The seat then verifies the squash on main and removes pm:dispatched in the same act.