A dev chart failed with 'Chart result column count does not match its decoder' on the buffered
/chart_data route, which never retried a bad connection; only the stream route did. The retry now
lives in fetchMetricsDataWithProgress, so both share it, and a row wider than its decoder raises
StreamDesynced naming the columns that arrived, so the next occurrence states its cause.
* Floating AI assistant: page-aware sessions that act, navigate and reload the page
Cmd+K or typing a letter opens the palette; Enter asks the assistant, which runs in the
background as a web conversation bound to the page it was asked from. The dock shows
sessions as bubbles, the selected transcript with live steps, and visits pages the agent
opens (open_page) or reloads the current page after a write.
* Dock polish: transcript-style progress, launcher with shortcut, entry motion; snapshot goldens
* Dock: OpenSession record, single-meaning navigate, inline bubble classes
* Dock panel reveals and focuses itself when a session first opens
* e2e: palette leads with Ask AI and hands the request to the dock
* Dock: catalog write policy, indexed session query, concurrent loads, 2s poll
* Dock: keep the changes toggle across sends; follow-up turn binds its page; lint
* hpack: list the page-context migration
* Dock: a log-view answer opens the explorer; prompt says only open_page changes the screen
* e2e: wait for the palette's lazy items before moving the selection
* Dock requests run on the receiving server; the queued job is a deferred fallback
* Browser tools: read_page, click and fill run in the user's tab; the run pauses until it answers
* Charts saved without a height get three rows; dashboard tools describe their body
* Dock reloads the current page by a whole swap; morphing a dashboard onto itself left it empty
* Stats saved without a height get two rows
* Assistant prompt lists a monitor's own page
* Page snapshot skips empty headings
* Assistant prompt: on-page parts of a request use the page tools; no unproven claims
* Document why the page tools carry a read-only policy
* Widget lifecycle spec: sizeless charts are three rows tall
* e2e: retry the palette's ArrowDown across the lazy items landing
* One prompt field for the thread and dock composers; tool names from the catalog
* Stored widgets get distinct ids; same-titled widgets no longer share one identity
* Widgets aggregating duration show time units; one inference for every widget
* A resize never redraws a chart before its data lands; echarts threw on the null source
* Dock: one let for the page change
* Distill: inline single-use tool list, merge height arms, dock spec helpers; hlint
Results and chat answers saved before runs pinned their charts re-queried the
live window, so a run's "11 ERROR events" sat under a stat reading 0 or 133.
Stored widgets now pin to the answer's time the way new runs do.
A run's tables re-queried the default window ending now, so a fixed Oct 31 hour
showed 45, 64, 0, 1 and 72 on successive loads of a live project instead of 145.
Browser-drawn charts already honoured timeFrom/timeTo; server-rendered tables,
top lists and stats now do too.
A run's tables showed "Widen the time range or loosen the dashboard filters" and
a "Show last 24 hours" button that changed the page, not the run's window.
Integration flakes that read back nothing after an ingest were undiagnosable:
the retry's `make ci-down` removed the services and their logs with them.
Docs, comments, formatting, workflow and deployment config, and test-only changes
are fully shown by the diff; recording them only replays the changed lines.
A lone legend entry only repeats the query's alias (count_) under a title that
already names the series; the chart takes the space back. Value-table legends stay.
Email charts were 900x300 exports shrunk into a 600px column, ~4px text on a
phone. An email profile renders 600x240 with Slack's 14px labels, on the
email's own surfaces and without alert annotations.
A report's weekly chart ended each side with "15:33:20": the window's boundary
ticks fall mid-day. Over two days or more the daily ticks mark the window.
A run's Visualizations re-parsed the raw answer, so its charts re-queried today.
They now pin to the run's start like the stored answer does.
Same-named containers listed pod, namespace, node and cluster on four lines even
when most were shared; rows now show only the fields that tell them apart.
* Container rows spell out pod, namespace, cluster and node only when another listed container shares the name
* A running routine's facts say when its run started instead of repeating the Running pill
* Routine pages read more clearly: latest-result heading wraps on phones and says later runs had no findings, secondary actions look like buttons, failure counts never clip, run summaries leave colour to the status pill
* Single-use run error tone moves beside its caller; latest-result separator matches the others
* Routines: status strip, informative run history, latest result, table list with actions menu
* Reports become AI routines: weekly on, daily paused; dated report documents, highlight charts, email delivery; remove legacy reports
* Wide tables: one-line headers with hints, compact container rows; routine documents panel polish
* Routines: run now, pause and resume from the routine page
* Tests: report routines specs, goldens for routines, wide tables and bot copy
* Routines on phones; docs and e2e for reports as routines
* Report runs: digest only on the report path, charts pinned to the report window
* Routines: choose in-app, email or Slack delivery; show delivery in the status
* Report routines: Observe policy, paid plans only
* fourmolu
* Routines: plain policy labels, clean wrapping facts, menu semantics, clearer intro
* Spec: run now starts an active report and leaves a paused one paused
* Routines: report view with a chart beside each highlight; one-line ask preview; plain policy names; compact stat widgets
* Routine actions disable while in flight
* Routine menu: start-aligned, divider before Delete; report hook matches run completions exhaustively
* Resume returns to the routine, like pause and run now
* Simplify: local times via local-time, shared run summary and chart image, Email only on reports, lighter report fetch, drop dead IssueSummary
* hlint
* Reports deliver to Slack by code like email; report templates install read-only
* Reports on real data: agents query both periods (a 1h default made weekly reports blind), exact period split, ms latency charts, enforced materiality; dev report preview
* hlint
* Routine page leads with the latest result; list shows runs that need attention; containers fit at 1280px
* Routines list keeps runs from deleted routines reachable; containers golden
* Reports deliver through the team fan-out alerts use (same recipients and channels, Discord too); one report window definition
* Routine actions stay top-right when the status line wraps
* Report routines run on Free too; a run keeps only the document versions it wrote
* Routine catalog cards lead with the title; schedule and reporting rule share one line
* Tables keep the first column's header on phones unless rows are selectable; routine ask reads as a quote; issue goldens for one-line headers
* Dashboard list golden: no bulk-action padding without selectable rows
* Report email preview charts latency in ms, as real reports do
* A routine's kept result pins its charts to the run; last-run outcome as a dot; phone routine page leads with the result; container rows show the workload, not a truncated image
* Report email separates highlights with a hairline
* Drop unused import
* Phone routine list shows the last outcome; PNG charts drop one-series legends; dark email button keeps contrast; workload badge without namespace; no one-item 'Show all'; category chips wrap
* Issue triage reports its outcome in plain words; a run that merged nothing has no findings
* Containers show Pod and Namespace columns from 1800px, so every column fits beside the filter rail
* Latest result shows when it was written
* Routine status line leaves the cadence to the header's schedule control for editors
* Needs attention: one row per run whose newest attempt failed, five shown; untitled routines' runs no longer read as deleted
* Containers drop columns no container reports (Pod, Namespace, Restarts, Ready under Docker); the name takes the width
* Containers spec pins which columns show for a mixed and a Docker-only inventory; golden tracks the container column again
* Run details: local time like the run list, attempt only on retries, a scheduled run's request no longer repeats its instructions
* Event-triggered routines get the routine composer too: no autofocus, 'Ask about these results'
* Routine health: recent failure count on the routine page, failed runs name their routine, Active reads as a dot
* Runs list skips the summary of the result already shown above
* Runs list calls an attempt a retry only after a failed one; a new push reads 'run N'
* A routine with no runs says so before its settings
* Issue autofix shows the fix runs it started and its real last run instead of 'Not run yet'
* Report charts leave a duration the agent already converted unlabelled, instead of calling 4.6 ms 4.6 ns
* Fix runs name the autofix routine that started them
* A routine's latest result reads as a record: no chat avatar gutter
* Review fixes: a path filter no longer drops a chart's ns unit; one showMore_ for runs, documents and attention lists; runFailed predicate
* Images: long tags truncate inside their column; drop the always-unavailable Security column (the drawer still explains SBOM coverage)
* Charts whose query is prose are dropped, not drawn empty; latest result notes newer quiet runs; Installed rows count recent failures; 'Result shown above'
* Routines list on phones: editors' status column gives way to the last-run outcome; failed runs put the routine name on its own line
* Phone routines list: last run and recent failure count on their own line
* Routine status line keeps 'Last run' on one line on phones
* Routines list failure count says it covers the last N runs
* A routine's last agent round can still save its document
Scheduled triage runs spent every round reading issues, then reached the
final round with no tools and reported that the day's document could not be
written. Since Nov 2 no routine kept a daily document. The final round now
offers save_artifact alone and honours that call; the round after offers none.
* Autofix run titles mark where a long issue title was cut
* Routine delivery menu posts a plain form field; disclosure class has no stray space
* Routine runs resolve their owning routine once; email delivery only for reports; undeliverable reports and retired jobs are logged
* One report item type and producer for email, chat and preview; one report template table; shared failed-runs note
* Routines list actions post without nested forms; the last agent round runs only the offered write; email delivery for a non-report routine is refused, not ignored
* The last agent round's unoffered calls leave its message too; row menu items never submit the table form
* nonEmpty for the kept tool calls
* Run history filter stays indexable; one report-template lookup; report charts use the pinned widget window; conversation titles mark their cut
* Remove report-only helpers weeder flagged; routines e2e follows Documents nav and unfolded runs; closing details returns focus to a routine's draft
* Phone composer shows its extras for a draft, not on focus, so tapping away doesn't shift the page; e2e matches dated document links
* Overview's country map works: server spans place by their peer, our own spans record the forwarded client, page loads count, top lists rank by count and say when empty
* Container rows keep their pod, namespace, cluster and node where those columns are hidden, so duplicates stay distinguishable
The hourly job moves every unedited catalog routine (and its opening message) to its template's current version and logs how many moved; provisioning no longer gates upgrades on repository analysis. Production's triage routine stayed on v1 after a successful analysis.
Production showed both routines idle: the hourly sweep ran on app replicas
without a sandbox ("Agent sandbox is not configured on this host"), and
triage could not page 1,562+ open issues inside one run. One longJob rule now
places jobs on the agent queue for seeding and enqueueing alike. Triage v2
compares new issues only against open issues of the same service and type,
and installed defaults still on their template's text follow newer versions.
* AI routines UI: render agent markdown, group PR threads under their routine, resizable sidebar
- Markdown MMark rejects (review reports with tables, images, <sub>) falls back to
sanitized GFM instead of printing raw source; textOnlyHtml is shared with the wiki.
- Query-less tables render their inline dataset rows (blank "Review query" widgets).
- PR-review threads leave the Conversations list; they live under their routine.
- Routine page: settings collapse into one disclosure; runs list is compact, titled
per subject (or attempt within one), shows errors, and folds older runs.
- Run inspector: icon-only close, separated metadata row, pretty-printed evidence,
link to the run's own thread.
- Sidebar edge drags to resize (persisted), double-click collapses.
- Lost-session failure says what to do instead of naming storage internals.
* Sidebar marks the PR routine active on its threads; test PR threads stay off the conversation list
* Impact review: the service-events chart reads its evidence window, not the page's range
* Monoscope-view review captions use Markdown, not <sub>; older runs keep their disclosure across live refresh
* PR threads lead with their result; blockquoted findings lose speech quotes; resizer keyboard steps don't lag the width transition
* AI views share one chevron disclosure for settings, run instructions and evidence
* Distill: one renderTable clause for inline and fetched rows; read-only policy text reuses policyLabel
* Proofs build the PR's own server: warm workspaces for every review
The review guest carries GHC with the server's compiled dependencies, Rust and Go. The worker's new
prepare script builds each pull request's base offline in its workspace checkpoint, so a proof
compiles only the change: monoscope-app --server rebuilds the server after a Lucid page edit in about
90 seconds, where the base build took 23 minutes. Workspace builds and checks get 4 CPUs and 6 GB.
* Guest: the review account writes cabal's build log
* Server proofs: room to build, toolchains on PATH, no stray symlink, honest records
Check sides get 300 s so a proof can build the head; the guest links GHC, cabal, cargo and go into
the reset environment's PATH; the root node_modules link is ignored; checkpoint manifests record
their real VM size; the guest's dependency stage builds from cabal files alone; Go builds no longer
rewrite go.mod; the worker pins 4 agent, 2 check and 1 build slots.
* Guest: build the shared library's source with the server's dependencies
* Guest: the server's dependencies include the local CLI package
A finished fix queues PublishFix on the agent queue. Personal GitHub tokens are tried first and attach the video and diagram; otherwise the App installation opens the draft PR linking Monoscope-signed media (new per-asset signed route). Fix-job failures now log their cause, and a failed autofix issue is retried a day later.
* install.sh: accept a pinned version without the v prefix
Release tags are v-prefixed, so `install.sh 0.6.31` built a /download/0.6.31/ URL that 404s.
* Re-run review
* Re-run review
* Live Tail: keep the toolbar on one line at desktop widths
The query editor's 288px flex-basis pushed the toolbar's basis widths past ~1047px, so Clear
wrapped onto a row of its own beneath the filters. A 256px basis fits; the editor still grows
to fill the remaining space.
* Live Tail toolbar: let the query editor shrink to 12rem so Pause and Clear stay on one row at 1280px
* Errors seen only from automated browsers get their own issues tab
The browser SDK marks webdriver sessions with OTel's user_agent.synthetic.type.
A pattern stays synthetic until a real occurrence arrives; synthetic issues are
kept out of the Inbox and every other tab and listed under Synthetic, and their
alerts say so.
* Serve browser SDK 0.13.3, which marks automated browsers as synthetic
* land: an unproven check blocks the merge
`make ci-status | grep -q` under pipefail read grep's early exit (make's SIGPIPE)
as "nothing pending", so #863 merged with e2e unproven.
* Synthetic issue filter probes a partial index
The bool_and subquery added 20-100 ms to every Inbox count on prod. Framework
issues group many patterns and are never synthetic.
* Migration 0279 was taken on master; this one is 0280
#862 changed only TypeScript, yet its image build recompiled 133 modules for
26 minutes: the cache's last writer predated #859, so every module #859 touched
looked changed. Only builds containing master write back now.
Install-time webhooks return no message timestamp, and a webhook post carries no metadata for the timestamp search,
so every root sent that way turned threadless and its replies ("Resolved by ...") landed in the channel alone.
The bot now posts whenever it can; the webhook is only the fallback when Slack refuses the bot (not_in_channel).
* Guests read package registries, so a proof or build can install a missing toolchain; frozen-check log assertion follows the 24 MB cap
- every guest gets GET/HEAD-only HTTPS to npm, PyPI, crates and rustup, the Go proxy, Hackage and ghcup, Maven and RubyGems, with a fixed User-Agent; GitHub is excluded except ghcup's metadata
- guests get udhcpc, which gondolin's init needs to bring up the network
- the agent is told to install missing tools with user-space installers; PROOF.md says not to build this repository cold
* Fresh nodes start warm from the lineage's archived build; workspace builds record a duration by outcome; plain proof clips crop to the rows they print
* fourmolu 0.19 and hlint
* Agent reach: fetch_url reads public docs through the host; list_issues and list_monitors read the review's mapped services
* fourmolu, hlint, docs for the new agent tools
* fourmolu
Nothing parsed the workflows (#859 broke Deploy with an expression no check read), and CI
regenerates monoscope.cabal before building, so a stale committed file (#858) passed every gate.
- A query may have only one summarize: the SQL compiler cannot nest them, so a second one is a positioned parse error.
- Monitors: every write path (form, widget, API create/PUT/PATCH, monitors-as-code) builds through monitorFromInput, and compileAlertSql is the one alert-SQL compiler (evaluation included).
- "Any results" means a count of at least 1 (migration 0279 fixes stored threshold-0 monitors).
- Below monitors read the lowest group and measure.
- 12h windows parse as 12 hours.
- The explorer editor reopens on the saved condition and window.
- Dashboard template variables are filled ("unset = all").
- Edits keep trigger history; an omitted active keeps a paused monitor paused; a query that does not compile is refused.
- One error predicate (isErrorSql/isErrorKql, agreement pinned against the evaluator), used by sessions, the errors flag, reports, bots, impact review and Issues.
- Uptime and cron writes need edit access, like the Prometheus targets that share their table.
- Monitor page chart follows vizFor, and its preview chart reads the monitor's own scope (Widget.scope, pinned_scope).
- Shared nativeDialog_/dialogTrigger_ and resourceList_ components, used for the Prometheus, review and remove-repository dialogs and the uptime/cron/Prometheus lists (status no longer colour-only).
- drawer_ closes on the server's closeModal, replacing four inline close scripts.
- Billing tables on Table via a gridClasses config field.
- parseSeverity replaces three log-level lists.
- Query builder reads a query that opens with summarize.
Seen by the recurrence watch: "Failed to load …/echarts.min.js" was an
unhandled rejection the browser SDK filed, and the cached rejection meant no
chart on that page tried again. The load is now forgotten on failure and
reported through logFailure.
* Deploys wait for the Mac's image; image-follow builds master's head; CI image bakes ffmpeg/graphviz; dashboard edits refuse missing dashboards, tabs and widgets
- release.sh: the deploy's image step waits up to wait_minutes for the image, and stops early once master moves on
- make image-follow: builds only master's newest head, cancelling a superseded build
- Dockerfile.deps bakes ffmpeg/graphviz; ci.sh's fallback install is bounded
- query-preview test polls for CodeMirror's time-sliced highlighting
- EditRefusal: DashboardGone/TabGone/WidgetGone join EditReadOnly in the route types
- CLI: disambiguate EventsSearchOpts record updates
* log-list test: poll for the load-newer reveal scroll, which lands on a later frame under load
* image-follow: an image already built for the merged tree counts
* hpack: list migration 0278 in monoscope.cabal
* Proof comments: issues found while testing, many claims per recording, a player bar, and a rating link
Recordings can prove several planned claims (covers), a review can check up to twelve, and anything
a recording shows broken that the PR does not claim becomes a caution callout. The preview's
timeline brackets the clip with its start and end times; the footer asks whether the proof got it
right through signed Yes and No links.
Also: deploys restart the proof worker only once no review is running; a saved proof setup is
dropped when .monoscope/PROOF.md changed since it was recorded; Live Tail keeps three-digit
milliseconds; plan_proofs is tested through the native host.
* Rating asks before it records; review follow-ups
A rating link only asks, and the button POSTs, so mail scanners and unfurlers that open every link
cannot answer. An issue must cite its recording; a retry clears an old rating; the rating question
appears only with recordings. A failed image pull fails the deploy again, and a second ship reuses
the pending restart. A truncated GitHub comparison and a failed one are both logged and drop the
saved setup. The player bar's right-hand time is the video's length.
Each failed only while sign-off compiled the image alongside: the drawer's
Add widget was clicked before htmx powered its form (no PUT was sent), two
multi-dashboard specs ran past their timeouts, and a history restore outlived
the default 5s.
- Every response carries X-Monoscope-Build (the frontend bundle the server
serves) and the page carries it in a meta tag; an htmx response naming a
different bundle reloads the tab once. A tab left open for months on SDK
0.11.6 kept filing errors that read as regressions of fixed code.
- scripts/land.sh / make land PR=<n>: sign off, wait for the tree's image,
merge only while master is still the base, else rebase and repeat.
Seen by the recurrence watch: "[Worker] Error: the log worker failed to load"
with no deploy nearby, so the stale-chunk reload did not cover it, and waiting
requests sat until the 2-minute timeout. The list now fetches on the main
thread, re-running what was waiting. The page builder the worker, the early
preload and the fallback share is one toPage.
Seen by the 24h recurrence watch: an empty body on the world geojson or the
echarts theme JSON ("Unexpected end of JSON input") was console.error'd and
filed as an issue. Both recover — the map loader retries on the next render
and charts keep echarts' default theme.
fetchJson passed any body with an error field through for the caller to route,
and a 401 answers {error: "unauthenticated"}: the log list showed that in the
query box instead of asking the reader to refresh.
The server links only profiled objects; cabal's vanilla pass exists to run
Template Haskell splices. Building it at -O0 (ghc-prof-options keeps the
profiled pass at -O1) cut it ~2.9x per module in a cold build. Dropping it via
-fexternal-interpreter is ruled out by the AutoInstrument plugin. New cache id,
since the build config changed.
A prove-it on #826 reused the progress comment an earlier review of the same head had updated, so
its answer landed far above the ask. A new ask now clears the run's progress comment.
rum.yaml is read_only, so it always renders the shipped YAML and edits go through
Duplicate. Migration 0277 keeps the one RUM row that froze its own layout as an
editable "(Customized)" copy and relinks the original, as 0266 did for the others.
* Handled browser failures stop becoming issues; fix three e2e flakes
- One fetch-failures module (ShownFailure, logFailure, fetchJson) for the log
list, its worker, charts and dashboard variables; the worker's fetch copy is gone.
- Chart HTTP errors and unreadable bodies, and variable-option 5xx/unreadable
responses, are shown to the reader and warned, not console.error'd.
- A log worker that fails to load (a tab open across a deploy) reloads once.
- Vendor browser SDK 0.13.2: transport failures are breadcrumbs, and error spans
carry exception.escaped, which the record extractor now reads as handled.
- query-preview forces its parse so a busy page never shows it unhighlighted.
- routines e2e: wait for the install/save redirects; drop 1s loading-bar budgets.
* Local test targets install the impact-review worker's packages, as CI does
* Dashboard read-only follow-ups: one refusal on every route, linking refuses built-ins, template tags and starring
- One ReadOnly refusal: rename, tab rename, reorder and duplicate-widget are Action
routes that declare it; widget saves, monitors and the YAML drawer reuse its message.
- assignDashboardRepository refuses a built-in itself, so the repository-folder path no
longer relies on a schema IS NOT NULL filter.
- Templates load once per request into an opaque Templates value; edit permission is
derived from it, and an empty list can no longer grant write access.
- Entrypoint tags and starring come from the template YAML (tags:, starred:).
- The refresh fill stays still under prefers-reduced-motion.
- live-reload and live-test-dev refuse to start past GHCI_MAX (default 6) GHCi sessions.
- Drop two redundant test imports.
* requireEditable takes the dashboard row; drop an unused lens import
* Simplify: linking returns the write proof, one sync refusal message, tab rename redirects through its outcome, budget check lives in reap-ghci.sh
* Proofs: the comment previews an eight-second clip around the highlighted moment, with a blue timeline of the whole recording; the full recording stays the video
* Proofs: hlint
* Proofs: the clip window is reported for terminal proofs only
* Workspaces: one build per base, restore from object storage on a miss, builds report how the checkpoint arrived
* Workspaces: restore-then-build reads as one case
* Workspaces: number the run base migration after master's 0275
pi-host aborted every agent at 420 s, so reviews that record proofs in the real app died after
#833 raised their budget to 30 minutes. The host now passes its budget to the agent.
Repository analysis installs issue-autofix for projects with a mapped GitHub repository. An hourly sweep queues up to three fix runs per project, on the long-job queue, for open non-API-change issues triage has had an hour with, pinning the mapping branch head (Git.headRevision) and the guest image (new CodeReview ResolveImage). Migration 0274 adds the issue_fix routine kind.
Merge/unmerge share Issues.mergeIssues/unmergeIssues across web, API, CLI and agent (bulk_issues merge|unmerge, with a reason). Repository analysis installs the hourly issue-triage routine once per project, never on the demo project; a deleted routine stays deleted, and automatic merges respect a person's unmerge.
* Proof comments update live and recordings sit in a browser frame
plan_proofs lists the claims a review will prove; the comment shows each as pending, running or
recorded while the agent works, and the finished review replaces that same comment. Recordings are
drawn inside a browser window with the page's title and URL, and the status icons are SVGs.
* Proof progress: approval-gated, current-run only, per attempt, and never left running
A progress comment waits for publication approval like the final review, only the current run
writes it, each attempt starts a fresh plan, a deleted comment is not reused, a failed proof shows
as not recorded, and a review that stops for good says so. plan_proofs spends the query budget and
takes at most three claims; drawtext keeps a URL's % literal.
Each 15-second refresh of a sliding range re-read its partial first bucket,
sending TimeFusion a 1-6s query per widget that no rollup can serve
(tiny_interior). A live range (no end bound) now starts at bucketStart, so its
first bucket is whole on the first fetch and every refresh.
monoscope-app swaps the checkout's Tailwind, static assets and web-components bundle into the
guest's production server, starts it against a Postgres migrated at image build time, and feeds
the demo project through real OTLP ingestion so Live Tail streams. PROOF.md records the whole
window, sidebar included.
Since reviews moved to background_jobs_long, the web replicas (IMPACT_REVIEW_VM_SLOTS=0,0,0, no KVM)
claimed review and workspace jobs and held them for the queue's 61-minute lock, so asked reviews sat
queued.
* Dual-exec: the TimeFusion arm outwaits a deploy drain instead of dropping the UPDATE
The TF arm of dualExecPgTfWithSql only logged and tripped the circuit on
failure, and nothing replays it, so every TimeFusion deploy drain dropped
the hash-tag and session-backfill UPDATEs (~99 per week). Retry transient
errors for up to 60s; every caller's UPDATE is guarded, so a re-run is a
no-op.
* TimeFusion dashboard: misses by reason include the shapes no rollup can serve
TimeFusion now exports tiny_interior, unaligned_bucket_width and
multi_scan_source as timefusion.rollup.unservable, outside the hit rate.
* Format BackgroundJobsSpec imports
Slow repositories build inside a review. One reviewSeconds sets the job timeout, the agent's
limit (a minute less) and the lease (five minutes more). Thirty minutes is past the main queue's
600 s timeout, which odd-jobs also treats as a stale lock, so review jobs go to background_jobs_long
wherever they are queued (queueJobTx routes by job); that runner admits eight at a time, still
bounded per node by VM slots.
The timeline label was written with the worker's non-UTF-8 locale, so every preview failed on
the play symbol and #826's ask fell back to unverified. The bench page left a blank strip beside
Live Tail; PROOF.md says how to match the app's content width.
@monoscope prove it now posts its review below the ask instead of editing the review comment
far above it; pushes keep updating the latest review. The preview carries a player-style
timeline: the full video, the part the preview covers, its moving position in brand blue, and a
Play full video label with the full length.
#826's first real UI proof summarised its method ("the base revision fails because...").
Claims now name the behaviour and say what a user sees now and saw before.
* Browser guest: let proofs write Vite's dependency cache
Proofs run as the agent account; Vite failed with EACCES creating node_modules/.vite under the
root-owned /opt/proof, so every UI proof rendered a blank page.
* Proofs: a browser preview that fits GitHub's image proxy
A GIF of a scrolling UI ran to 6 MB for eight seconds, past what GitHub's proxy will show.
The preview is now an animated WebP at the sharpest of three settings that stays under
4.5 MB; it keeps its .gif URL so existing comment links work, and is served by its bytes.
* Browser guest: Playwright finds its browsers under a reset environment; PROOF.md script as a file
#826's first proofs failed: proof commands run with setpriv --reset-env, which drops
PLAYWRIGHT_BROWSERS_PATH, so Playwright looked in ~/.cache; and the agent's inline node -e
script broke on quoting. The guest links the default path to /opt/proof/browsers, and the
recipe writes the script with a quoted heredoc.
A UI proof drives the page with Playwright and writes a video, labelled screenshots and
chapters to $PROOF_MEDIA; proof.sh returns them between the log markers the cast already
uses, parsed by one section reader. The host renders the video as a full-width GIF and an
MP4, stores screenshots per side, and serves them as proof-N-side-i.png (ProofAsset).
The comment now leads like a reviewer's proof: the claim that matters most, its recording
with chapter links, merge-base and pull-request stills, then the other claims a line each;
the merge-risk table follows.
Check VMs get 4 CPUs and 4 GB (Chromium and a dev server) and a 24 MB log. A browser guest
profile adds Node, Playwright's Chromium and the root and web-components dependencies;
.monoscope/PROOF.md documents the recipe for web-components UI changes.
A second delivery of @monoscope prove it re-queued a completed review. Its fresh execution found
no saved session and the finished review's model calls, and failed as a lost session; every
retry then landed on a zero-slot node that re-deferred it as a new job with fresh odd-jobs
attempts, so it failed 54 times. The session guard now applies only to continuations, a lost
session ends the chain, and agent retries stop after three executions in one chain.
Publication recovery reuses the stored result and keeps retrying until it reconciles.
make ship now rebuilds the proof worker from the deployed production image (only its own
layers build) and restarts it on IMPACT_WORKER_HOST; make deploy-worker does it alone.
The gnu agg build needs glibc 2.38 and the bookworm runtime has 2.36, so every
proof recorded but none rendered; amd64 now takes the static musl build.
Guest rootfs was sized to its contents, so copying a checkout into /workspace
ran out of space. VMs now boot with a 64G sparse copy-on-write rootfs that
gondolin grows with resize2fs; only written bytes use host disk, and guest
images need no sizing.
* Identify replay users and stop filing handled browser failures as issues
- Vendor browser SDK 0.13.1: replays carry the constructor's user (they were
all stored anonymous), zone.js leaves IntersectionObserver alone, and
non-Error rejections are described instead of "[object Object]".
- An error pattern's sample adopts the first occurrence that names a user,
so a sample stored anonymously no longer keeps the User card empty.
- Log explorer: fetch failures the reader is already shown are warned, not
console.error'd; the worker reports an empty body instead of throwing
"Unexpected end of JSON input".
- Chart options: binding formatters no longer recurses into DOM elements
(stack overflow on dashboards).
- Table/stat widgets select by [id='…'], valid for ids starting with a digit.
* Doctest the [id='…'] selector form in the AI chat history
* One ShownFailure/logFailure for failures the reader already sees
* Alerts name the user's email and the tenant; samples adopt a later tenant
- Error alert footer: "User Ada Lovelace (ada@example.com)".
- Tenant falls back to tenant.id / organization.id when no name is sent.
- An error pattern's sample is replaced when an occurrence identifies more
(user, tenant) than it does, so a tenant sent later reaches alerts.
* Issue detail snapshot carries tenant_id
* Lifecycle replies send at once; PR #810 review follow-ups
- A lifecycle action queues a DeliverSlackIncidents job beside its replies,
and the worker drains every thread within one run (bounded), so an
acknowledge, assign and comment arrive within seconds instead of a tick apart.
- One SlackRelay classification replaces two exhaustive tables; doctests pin
the JSON keys the claim SQL builds for Ownership and ActivityNote.
- openEpisodeTx and emailFanout replace repeated episode and fan-out code;
check alerts take a named record; uptime/cron names are shared.
- sendAlertToChannels reports a Slack alert it could not record as not sent
(email still goes), with a regression test.
- A check's recovery, archive and resolution log commit in one transaction.
- Agent markdown answers can no longer ping: <!channel>, <!here> and <@U…> are
neutralised (Slack turns them into real mentions inside markdown blocks).
- Escalation change is a Maybe with a doctested percentChange; spike charts
share one hourly-volume query per detection run.
- Next-day recovery broadcast is tested; the Slack gallery golden is pretty-printed.
* Error-alert tests count a reminder's reply and root edit from one run
* Remove resolveIssues, orphaned by the transactional recovery
* Slack follow-ups: exhaustive relay case, one pause check, bounded drain logs when it runs out, enqueue test pins the payload and the no-thread case
* Review follow-ups: series prepend, one name-or-fallback, userLabel beside User, end-to-end broadcast quoting test
* fourmolu
* hpack
* Write geo.country.iso_code to its promoted column on both legs
TimeFusion's storage was widened on 2026-11-08 and timefusion#450 declares the
column; 0267 is the Postgres half, since one insert serves both legs. Listing it
in the flattened set lets KQL read the column instead of the attributes blob.
Merge only after timefusion#450 is deployed: until then TF rejects the insert.
* Number the geo column migration after master's 0267
* Number the geo column migration after master's 0271
* otelColumns count doctest: 92 with the promoted geo country column
* WIP sandboxes: host VM slots, low CPU priority, per-project review cap, proof setup recipes
* Sandboxes: prepare workspaces in their own job, warm from the repository's latest build; three slot pools; host-wide review cap
* Sandboxes: warm starts verified in real VMs; located workspace errors; hour-long build budget; admission and recipe tests
* Sandboxes: docs for admission, warm workspaces and recipes; hlint
* Sandboxes: builds in their own hour-long queue, locked per-node admission, cold fallback, setup cannot edit source
- background_jobs_long: one build at a time, 61-minute timeout; the main queue's timeout is also its stale-lock threshold
- claimRun takes an advisory lock and counts each node against its own agent slots (IMPACT_REVIEW_VM_SLOTS)
- builds wait for their slot; ionice best-effort 7 instead of idle
- a failed warm start forgets the ancestor and retries cold; .git is replaced from the host checkout before root runs git
- a proof setup that moves the commit or edits a tracked file fails the proof
- setup passed once beside the proof sides; recipe reuse classified in the upsert
* Sandboxes: workspace builds fetch with a five-field Checkout.Fetch, setup reuse is a sum type, review-loop distillation
- Checkout.Repository takes anything with the fields a checkout reads, so builds pass no placeholder agent fields
- saveProofs reports SetupReuse (no_setup, reused, changed) from the recipe upsert
- single-use reviewsPerProject inlined; test job drain is one union
* Sandboxes: simplify pass — checkout takes a Fetch, one build budget, a no-op build holds no slot, ancestors match by lineage
* Sandboxes: fourmolu 0.19 and hlint
The unit spec strips placeholders to parse each widget query standalone; the new
request_kql preset left the Overview's queries unparseable there, failing CI.
"HTTP Errors (4xx & 5xx) - Incoming" also counted outbound calls the SDK captured, and
outbound calls have no visitor to locate. Both now filter kind == "server". Neither
was routable to TimeFusion's dashboard rollup (they filter on the response status and
geo attributes), so nothing leaves the fast path. HTTP Stats stays inbound-only and now
says how that differs from the Overview's Traffic.
Ingest decided "is this a browser?" with its own predicate, which lacked the page-view names
browserKql counts. A page view from the OpenTelemetry web SDK (no sdk.language, no user agent)
was on the RUM map's population but never adopted its sender's address, so it was never placed.
placeRecords now evaluates browserKql itself (Pkg.Parser.isBrowserRecord, via the Live Tail
evaluator), and three copies in Endpoint Analytics use {{browser_filter}}.
The Overview's inbound-plus-SDK traffic filter, repeated ten times, is now {{request_kql}}. Its
text is unchanged: TimeFusion's dashboard rollups declare the compiled SQL verbatim.
* Slack alerts share one card anatomy; issue lifecycle replies in the issue's thread
- Every alert (errors, monitors, log patterns, spikes, endpoints, reports) renders
through one Card: status emoji + word + bar colour agree, then facts, evidence,
chart, footer, actions. Thread replies are one line.
- Root edits merge by block id and keep the onset chart.
- Slack chart PNGs render dark by default, on Slack's own dark surface.
- Acknowledge, assign, comment, archive, resolve, link, merge and spam actions
reply in the latest thread each channel holds for the issue (post_activity);
threadless roots never get them as channel posts.
- Recovery and resolution are also sent to the channel when they are a
thread's first news of the day.
* Log patterns and spikes thread through the incident outbox
A recurring spike reopens its pattern's one issue and replies in that thread,
sent to the channel when it is the thread's first news of the day. Rate-change
issues refresh their title on recurrence, as monitors do.
* API acknowledge and archive record activity, so their Slack threads hear about them
* Gallery covers lifecycle replies; comment quotes and resolutions read the same everywhere
* Slack agent answers lead, in native markdown and tables
- Answers go out as a Slack markdown block: headings, lists, code and pipe
tables render natively instead of as raw markdown in mrkdwn sections.
- Query results render as a Slack table block, not a fixed-width code block.
- The answer is posted before its charts; charts render dark at Slack size.
- A Slack-specific format section asks for a one-sentence answer, at most five
evidence bullets, tables for comparisons, and under 120 words.
- One 'Queries and run details' link under the last reply, not one per part.
* Slack progress names what each step checks
One reasoning step per run instead of one per model turn; tool steps carry
their subject (the query, field, file or service) in plain bounded text; the
caption reads 'Updated 14:02:07 UTC · steps show what was checked, not what
was proven'.
* Distill Slack card builders: one base card, escaped bold, one-line replies
* Lifecycle deliveries carry a typed activity note; relay decision is exhaustive
* Keep single-use Slack helpers at their use site
* Drop comments that restate code
* Design review round 1: ownership on the root, rate leads, cards keep their identity
- The root shows who acknowledged (until when) and who is assigned, rendered
from the issue's current state on every root edit and after lifecycle replies.
- The error rate moves into the bold facts line; evidence shows stack frames
when the title already carries the message.
- A resolved root keeps its title and says who resolved it and when.
- Every status leads with the tone circle matching its bar; Slack's green
primary button only on calm cards; monitors say above/below in every state.
- Replies' notification text names the issue; impact names the user without
posting an email address; new-endpoint and report cards follow the anatomy.
* Design review round 2: notification text leads with the issue; resolved roots style their own actions
* Simplify pass: ownership root edits go through the outbox; shared helpers
- An ownership change queues an update_root delivery beside its reply, so the
root edit is ordered, retried and tagged as a root like every other edit.
- The relay join filters by project so it uses the episode index; ownership is
looked up only for root renders.
- One block-id helper for snapshot merges and ownership; display names and
truncation live beside User and in Utils.
* Tests follow the new alert wording; thread replies carry no links
* fourmolu
* Use Relude's NonEmpty init/last
* hpack: list the new migration
* Doctests: truncateText keeps truncateMiddle's examples attached; GeoIP doctest Map alias no longer ambiguous
* Uptime checks and cron monitors notify
A confirmed downtime, a missed cron window or a failed run reopens the check's
one issue and alerts through the issue path: a Slack card through the incident
outbox, plus email, Discord, PagerDuty and WhatsApp, with the usual cooldown and
rate limit. Recovery replies in the same thread, turns the card green and sends
the recovery to the other channels (PagerDuty resolves).
* Log spikes chart against their baseline; monitor cards name the project; escalations say what they rose from; stat answers post the number
- Widget gains an optional baseline line; a spike alert charts the pattern's
last day of hourly volume against it.
- Monitor cards carry the project in their footer, like every other card.
- An escalation reply reads '*120/hr* · was 12/hr · *+900%*'.
- In Slack, a stat widget from the agent posts its value as a header with its
title and query, falling back to the chart image when the value is unknown.
* Uptime recovery replaces the failing reading; evidence keeps only what the facts don't say
* fourmolu
Ingest (OtlpServer.placeRecords) stamps geo.country.iso_code / geo.region.{iso_code,name} /
geo.locality.name on every span and log from its client.address, once per distinct address
per batch, unless the SDK sent geo.* itself. Errors now read geo from the row, so the
errors-only enrichGeo is gone. Before this, 30 days placed 307 error events in total.
A browser's client is its sender: the collector (resource/sender, X-Real-IP only, since a
browser can set X-Forwarded-For and nothing fronts the collector with Cloudflare) and the
OTLP/HTTP routes record it as monoscope.sender_ip; ingest adopts it as the browser's
client.address and drops it from every other resource.
Dashboards: `type: geomap` renders a log-shaded world choropleth (Natural Earth 110m,
fetched only when a map is on the page; also drawn by chart-cli for PNG export). Added
"Page views / Requests by country" with a top-countries list to RUM, Overview, HTTP Stats
and Endpoint Analytics. An empty map keeps the world visible with a caption.
Also: the Overview's request latency heatmap.
* Restore swipe navigation and pull-to-refresh; dark overscroll background
overscroll-behavior: none on html/body disabled swipe back/forward and
pull-to-refresh across the app. The root now leaves gestures alone and
only horizontal scrollers (.overflow-x-auto/-scroll) contain their x
overscroll, so a table scrolled to its edge still doesn't navigate.
The theme attribute is mirrored onto <html>: overscroll reveals html's
background, which sat outside body's tokens and showed white in dark mode.
* Overview dashboard: USE-method Infra tab, fixed Logs, service infra; chart fixes
Infra tab rebuilt after Grafana's Kubernetes compute-resources and Node
Exporter dashboards: cluster stats, per-container CPU/memory/% of limit/
restarts table, memory headroom, network, nodes, workload availability,
Kafka lag, runtimes and hosts. The old tab read metrics no receiver sends.
Logs derives severity from the OTel severity number and scopes the stream
by service; Service gains its containers' CPU, memory vs limit and network;
Databases gains server connections, cache hit ratio and throughput;
Overview gains a saturation stat and slowest endpoints.
Charts: duration line charts use a log y-axis so one long request no
longer flattens every percentile; sparse metric series bridge empty bins;
legends no longer cut the widest name by a floored column width or a
shared canvas font. Table byte columns format as KiB/MiB/GiB.
* Search inputs keep their height and UI text size
searchInput_ shrank inside flex columns (the facet sidebar squeezed its 36px
box to 22px) and inherited daisyUI's 16px text beside 14px UI text. It now
holds its height and reads at text-sm, keeping 16px on phones so iOS does not
zoom on focus. The facet search sits on the soft fill like the header search.
* Latency heatmap for dashboards and the Explorer; legend toggles rescale charts
A heatmap widget and Explorer view, after Datadog and Dash0: time across,
log-scaled latency buckets up the side, count as shade, cells holding errors
in red. KQL gains log_bin(x), four buckets per decade, so the default query is
summarize count() by bin_auto(timestamp), log_bin(duration),
iff(status_code == "ERROR", "error", "ok"). The ladder keeps empty steps,
shading is by log count over solid ramps the count scale shares, and the
Errors/OK legend hides either layer. The Overview template's Service and
Databases tabs gain latency heatmaps.
Latency lines stay linear so a spike reads as one; hiding a series in a legend
now refits the y axis to the series left.
* Explorer's latency chart is the heatmap
Per-bin percentiles of a few hundred requests read as noise: p90/p95 jittered
30-200ms every bin while p50/p75 lay flat. The Explorer's second chart is now
the latency heatmap with error cells, as Datadog's, Honeycomb's and Dash0's
explorers show it. Cell gaps drop when cells are too small to separate, so a
short panel reads as one shape instead of stripes.
* Heatmaps survive resize and theme changes
Both redraws reused the server's time-series option and merged it over the
drawn heatmap, leaving category axes with no cells. They now rebuild the
heatmap from its data and replace the chart.
* Explorer: percentiles by default, latency heatmap one click away
The timeline row shows All traces and Latency percentiles again. A two-icon
Percentiles/Heatmap toggle in the latency header, just before its menu, swaps
the row to one full-width heatmap; the heatmap's header carries the same toggle
at the same spot, so switching back never moves the pointer. One radio pair and
group-has variants drive it; the choice is remembered per browser.
widgetWith_ gives a widget's header a slot for the page's own controls without
storing them on the widget, so a chart copied to a dashboard leaves them behind.
Goldens record the search input's shrink-0/text-sm and the facet search's fill
from 3dcdd4a04.
* Clicking a heatmap cell loads its events
A cell carries its time bin and value bucket. In the Explorer a click narrows the
range to that bin and adds `<field> >= low and <field> < high` (the field log_bin
buckets), plus status_code == "ERROR" for a red cell, to the query; from the
Heatmap view it switches to the list. On a dashboard it opens the Explorer on the
widget's own filter, its variables filled from the page, and the same clauses.
* Heatmap cells with errors ask whether to open all events or only the errors
A plain cell opens all of its events; the status filter is no longer added implicitly.
* Issues list: truthful counts and sparklines, whole-row click, steadier rows
Counts colour by volume only within the period; sparklines are neutral and
draw nothing for empty buckets. Rows drop the severity tint, the meaningless
neutral status icon and the Users column (folded into the count line). Hover
actions sit at a fixed edge, the row opens the issue via Table's rowLink
(which now ignores clicks on inner controls), type filters share the tab
strip, and grouped tables lose a stagger that never ran.
* Add-to-dashboard picker: searchable list, read-only rows locked, new dashboard with the widget
The copy/add modal reused the dashboards management table, which rendered
misaligned columns with no search and let read-only dashboards be picked only
to fail. It is now a compact, keyboard-navigable list: widget name in the
header, search with arrow/Enter, favourites first, built-in dashboards locked
at the end, and an inline form that creates a dashboard starting with the
widget. Toasts now render their detail line and can link to the page an
action touched, so "Added to X" opens X.
* Issue page: the error before its context, the event dated in its own header
- Runtime exception sections follow Sentry's order: highlights, the error
and stack, the request, tags, then contexts and grouping.
- The selected occurrence's time sits in the Event header beside the
occurrence controls, in the viewer's zone like the chart beside it.
- Embedded log lists (issue logs and events, host logs) say why they are
empty instead of offering "Clear query", which dropped the page's scope
and listed the whole project.
- Frames without a file emphasise the method over namespace and arguments.
- The embedded trace drops its date row and gap; the event header dates it.
- Time axes label day ticks "Nov 8" rather than a bare "8".
- User-journey offsets no longer wrap.
* Infrastructure: kubelet-only nodes report CPU, memory and disk; tables fit
Nodes measured by kubeletstats alone showed dashes for everything: the host
pivot read only hostmetrics' system.* series. It now falls back to the
k8s.node.* series - working set over working set + available for memory,
filesystem usage over capacity for disk, and CPU in cores, since the
kubelet reports no core count to make a percentage of. The host drawer
charts the same source the row came from.
Inventory tables overflowed their card at 1440px and clipped trailing
columns: name columns now truncate instead of sizing to the longest name,
low-signal columns wait for 2xl, limit headers wrap, and host integrations
are labelled icons rather than clipped words.
* Host map opens on the signal the most hosts report
Kubelet-only nodes have memory and disk but no CPU percentage, so the CPU
default greyed them out as "no data". An unpicked fill now follows coverage.
* RUM: a Network tab and the page-load distribution
The dashboard had no view of what the browser fetches. The Network tab
covers the app's API calls as users experience them: volume, failure share,
P75/P95, responses by status class, a latency heatmap, per-endpoint rows
with ids masked and an Explorer drill-down, and the slowest static assets.
The OTLP exporter's and session replay's own uploads are excluded.
Overview gains a page-load heatmap, which shows the slow minority a P75
averages away.
* Repositories: reviews show their outcome; usage folds away; real empty states
The pull-request list named a review only by its PR number and status, so
finding the one with something to check meant opening each. A Result column
shows the verdict: findings to check, no finding, or coverage unknown.
Project model and sandbox accounting moves into a closed disclosure so the
list leads the tab. Issue fixes and Usage use the shared empty state, and
the fixes one points at where a fix starts.
* Repository page: a failed sync says what failed; review links get room
"HTTP 422" sat alone in red under Dashboards and monitors. It is now an
error callout titled by the operation that failed (import or export). The
review history button and routine link no longer run into each other.
* UI review pass: shared listbox nav in the picker, one utilization scale, press feedback
From /better-ui and /emil-design-eng passes over the session's work:
- The dashboard picker uses Components.listboxNavAttr_ instead of two
hand-rolled key handlers, so focus stays in the search while arrows move
the highlight. Read-only rows are aria-disabled rather than disabled, so
their tooltip shows; an add in flight dims and locks the rest.
- Containers and hosts drew the same percentage with different colours
(75/90 brand vs 60/85 green). One scale now serves every bar and the map.
- The heatmap cell menu enters from its click point; its items, the Ask AI
tab and Send acknowledge a press.
- A superseded review's verdict is muted: it is history, not a to-do.
* Press feedback uses the 0.96 scale used everywhere else
* Heatmap cell menu enters on the project's ease-out-quint curve
* Review fixes: typed source dashboard, malformed widgets refused, one verdict mapping
From /hs-distill, /hs-evasion-review and /hs-lob-review over the session:
- DashboardForm's sourceDashboardId is a DashboardId decoded at the form
boundary; the picker disables its empty hidden inputs instead of the
handler filtering "" and re-parsing text.
- A widget JSON that will not decode is refused before the dashboard is
inserted, rather than leaving a new, empty dashboard behind (test added).
- The review Result column maps a verdict to tone, icon and label once.
- Picker row classes are written inline at each row.
* Doctests: ContainerRow builder carries nodeStats; log_bin expectation includes its alias
* Simplify pass: one client-request filter, one toast entry point, empty form values read as absent
From /simplify (reuse, simplification, efficiency, altitude agents):
- RUM's Network widgets share a {{client_request_filter}} preset instead of
six copies of the SDK-upload exclusion.
- addToast takes the optional link itself; pushToast is gone.
- FormWithOptional drops empty values for a list of keys, so the picker's
empty hidden fields decode as absent server-side; the client stops
toggling disabled on them.
- The review Result column carries Maybe a tone instead of a dead one; the
picker's no-match line is the shared compact empty state; the dashboards
table builds one column list; the host map's best fill sorts a NonEmpty.
Skipped, noted in review: a TimeFusion-unverified regexp backreference
rewrite, a HostSource sum, a WidgetSource refactor across handlers, a Toast
record, and a Table fill-column combinator spanning pre-existing pages.
* e2e: assert the picker by its listbox; disambiguate the dashboard title input
The add/copy picker carries its own new-dashboard form in the global modal,
so input[name=title] and the Create button now match twice on the
dashboards list. Specs take the first, as the others already do.
- Duration and percentage charts headline their peak unless summarize_by says otherwise, and show no "/min" rate; plain stats keep their value
- A lone hashed series takes the brand colour instead of a red or amber that reads as an error
- series_intent: error widgets read "0 errors" / "No errors in this time range" instead of "—" / "No data"
- "Other (k)" folds non-additive series by their max, not a sum of p95s
- Chart series ignore pointer hover; only legend hover fades the others, so the axis tooltip's lines stay visible
- Total Time no longer truncates to whole seconds (SUM(duration) cast to float before dividing)
- Time-series limits raised tenfold (2000 -> 20000 etc.) so the oldest part of the range renders
* Dashboard polish: stale-data chip, sparklines fit their data, stat precision, table cells
- Stale refreshes show a warning (a corner chip on stat tiles) instead of the failure banner
- Sparklines fit the y-axis to their data; thresholds show once the series nears them
- Stat cards and table columns take `decimals` (Apdex reads 1.00 / 1, 0.99)
- Latency axes label every tick in one unit; percentiles get distinct hues; "Other (k)" is neutral
- Table cells: tidy durations, an em dash for missing values, a copy check drawn in CSS,
and an empty state that offers the next wider window
- Overview: Apdex as a sparkline stat, plain-stat rows centre their values, chart placeholders fill
the plot area without repainting every frame
* Fix master: issue goldens carry the chart grid's right inset; e2e expects Overview's single Service filter; narrow tables keep their header row accessible
* Share one dashboard duplicate; only DashboardTemplates grants write access
Duplicating a repository-synced dashboard from the UI kept its (repository, file)
key and failed on the unique index; the web and API copies now share one
'duplicate' that detaches the copy from its template and its repository. The
Editable witness moves beside updateSchema/updateTitle so no caller can mint one
from an empty template list. Entrypoint titles and starring come from the template.
* Review fixes: the YAML route answers read-only in its own outcome; one API dashboard lookup
* Distill read-only dashboard spec fixtures
* Simplify: one template lookup from the auth context, one dashTitle, updateTitle takes only the witness
* Regenerate monoscope.cabal for migrations 0265 and 0266
* Clear three hlint hints in the widget table renderer
- Log explorer: a query's result shape (events, scalar, time series, categories)
picks the view server-side; VizType replaces string viz keys; charts shape their
own query on the server (chartQuery) instead of regex rewrites in the browser.
- Top list renders as a grouped, bar-in-cell table; PNG legends fold the long tail
and wrap.
- Dashboard tables: content-sized columns with long text flexing, two-line monospace
code cells, one bar per row, sortable full-cell headers, short IDs, local timestamps,
stacked rows in narrow widgets.
- Chart legends: left-aligned grid without the shared name prefix.
- Dashboards: breadcrumb switcher (lazy popover, starred first), read-only widget
drawer, template icons fixed (migration 0265), saved "All services" view removed.
- Stat formatting: small fractions, singular units.
While live, the Pause button fills with a faint brand tint over one refresh interval
and empties the moment the refresh fires, so the next refresh is visible at a glance.
It is driven by the refresh timer itself; a control swapped in mid-cycle joins at the
elapsed point.
Templates marked read_only render from the YAML whatever their row stores, so
deploys reach every project. Content writes need an Editable witness that only
non-read-only rows yield: the UI offers "Duplicate to edit", and the page,
API and repository-link paths refuse. Duplicating (or creating one from the
gallery) makes a detached, editable copy. Migration 0266 keeps a customised
built-in as "<title> (Customized)" and relinks the original.
Route records live in Web.Links, below the pages, so pages build links with urls.field and a renamed or reshaped route fails to compile wherever it is linked. Page-defined response/body types appear there as Opaque/Opaque1 labels that Web.Routes resolves; no .hs-boot files or SOURCE imports. Kafka consumer cleanup keeps pause, commit and stall state in its owning loop.
* Typed follow-ups: GitConnError, /api/v1 problem envelope declared per route, typed GET fragments
Pkg.Git local validation returns GitConnError instead of Text. /api/v1 refusals and
Servant's own rejections answer one {"error": ApiProblem} envelope, declared per
route via Refuses for OpenAPI/MCP; the CLI prints its message. Remaining
RespHeaders (Html ()) fragments (Telemetry, Issues, CodeContext, Dashboards,
Settings, LogExplorer) return typed view values.
* Review fixes: closed ProblemCode shared with the CLI, split git origin errors, MCP shows refusal messages
ApiProblem moves to monoscope-shared with a closed ProblemCode enum; ApiError
owns every code. Servant rejections no longer guess a field from message text.
Refuses takes one status per combinator. Origin/endpoint/connection errors are
separate types; snippets report ConnectionInvalid. Metric fragments share one
record; the code-mappings picker route returns the fragment it swaps.
The test harness loads .env and kept its KAFKA_BROKERS, so the replay upload
spec published to whatever broker the local .env named. Tests now blank
kafkaBrokers, and getOrInitKafkaProducer throws instead of building a
brokerless producer that silently drops what it enqueues.
* Typed htmx action outcomes: route types list refusals, handlers return domain values
Web.Outcome adds HxPost e a (UVerb: 200 outcome | 422 refusal) and hxAction/hxDone.
AIThreads and the monitor uptime/cron/alert handlers return outcome records and
per-endpoint error sums instead of RespHeaders (Html ()) and Either Text.
* Type /api/v1 refusals and webhook rejections
ApiHandlers' 404/400/401/403 bodies come from one ApiError sum (wire unchanged).
Git.verifyWebhook returns WebhookRejection, so the metric label is a total case
instead of substring-matching the error text.
* Typed outcomes for Projects, Settings, Issues, Dashboards and CodeContext actions
Refusals become per-endpoint sums (ChannelsRejection, TeamRejection, ScrapeRejection,
ErrorPatternRejection, TimelineRejection, WidgetMonitorRejection, MappingRejection, ...)
declared in the route types; success values are records whose HxOutcome owns the
redirect/toast. PagerDuty/Slack integration changes now require edit permission
(they mutated before any role check).
* Typed refusals for bots, GitSync and remaining Pages actions
Slack/Discord answer through one refusal sum each (wire bytes unchanged);
Issues.commandOrigin/incidentChannel return typed errors. GitSync settings render
from a record with a typed failure instead of a Maybe Text message.
* Review fixes: refused assignee saves nothing and resets its select; invalid widget monitor query is a refusal
Also fixes two htmx-4 handlers filtering on detail.successful (never set), so
Remove monitor closes its drawer and the resolve button removes itself again.
* Format with fourmolu 0.19; satisfy hlint
* Name action answers by what they are, not by htmx: Action/act/done, Outcome/Refusal, in System.Types
Web.Outcome's Hx* names read as htmx attributes (hxPost_, HXRedirect). The types
now live beside RespHeaders in System.Types: routes are Action/Unrefusable,
handlers return ActionResult via act/done, Outcome owns body/redirect/toast
(no ToHtml superclass, no NoBody), Refusal owns the message.
* Format with fourmolu 0.19
* Derive standalone instances; widget saves refuse before writing
Widget PUT answered 200 with an empty body (an empty Outcome instance), so the
editor never adopted the saved widget. It now returns a typed WidgetSaved whose
body is the widget and whose toast names the change. Both widget saves validate
everything before writing: an uncompilable monitor query is MonitorQueryInvalid
(compileAlertSql is now total and shared), and a vanished widget is
WidgetNotFound instead of an untyped 404.
Says/Mime via-wrappers replace 17 fixed-message Refusal/Outcome instances and 6
Accept instances; DB, JSON and HTTP codecs derive where the output is
identical; LatencyHist derives via monoidal-containers. Plan in
docs/plans/derive-standalone-instances.md.
ghcid stops cabal repl but not its setup/ghc children, which reparent to
launchd and keep 5-50 GB each (15 of them, ~132 GB, froze the Mac; two held
:8080 with stale code). Both watchers now reap before each start and after
each load. CI stacks of deleted clones are swept on every local run and down.
* Fix url_path reaching SQL raw; stop filing variable rejections and stale virtual rows as exceptions
- KQL: url_path passed validation but rendered as a bare column, so
TimeFusion answered "No field named url_path". It is now an output
field alias (also covering live-tail eval), replacing two special cases.
- Dashboard variables: a 4xx or error payload from /chart_data is the
author's query, not a fault. Mark the picker (red border, message as
title) instead of console.error, which the SDK files as critical.
- log-list: lit-virtualizer 2.1.1 renders a range measured before the
list shrank, passing undefined rows to keyFunction/renderItem.
* Update dashboard saved-views snapshot for the invalid-variable border
ensureRoutineTemplate is shared by the routine catalog and the Slack install:
an existing installation is left as its owner set it, so a reconnect adds none.
Adds the Slack coworker agent plan.
- shared/src/Web/Operations.hs declares every /api/v1 operation once: MCP tool
name, agent access, description, and its CLI command, arguments and listing
columns. AgentCatalog.apiOperations and the CLI's per-resource command types,
parsers and dispatch now derive from it; a generic parser and runCall replace
them, and ResourceKind is gone. Typed Method/Verb, Input, Arg and Listing keep
invalid argument shapes unrepresentable.
- Agent local tools: single-use KQL/tool helpers folded into executeLocal; tool
names in errors come from the operation. get_code_context no longer builds a
throwaway cache (fetchSourceEvidence takes Maybe Cache).
- Derived names: constructorName (Generic) for actionName/operationName,
slackReadName via encodeEnumSC (SearchPersonal -> SearchPublicAndPrivate),
StreamFrame ToJSON via deriving-aeson.
- CLI charts on granite (round ticks, exact x range, width-exact) and tables on
table-layout (widest column absorbs overflow, single-line header rule).
- retry replaces hand-rolled backoff in retryOnDeadlock, retryOnPoolExhaustion
and the CLI's withRetry; agoText replaces prettyTimeShort; http-types urlEncode
in the CLI; text-metrics levenshtein replaces editDistance.
Net about -970 lines.
* widgets: don't console.error a chart's own query rejection or a lapsed session
The browser SDK files console.error as a runtime exception, so a user's KQL typo
(Unknown field "npdy", syntax errors) became a critical monoscope-ui issue. Those
are already shown in the chart banner; only failures the user did not cause
(e.g. a 503) still report.
* dashboards: don't report a settle sample beyond the server's 10-minute bound
A dashboard opened in a background tab settled long after load, sent a duration
over 600000ms, and earned a 400 that filed a runtime-exception issue.
#619 gated aiSearchH on a project_members row, which the demo project does not
have, so every demo visitor got 403. It now uses sessionAndProject like the other
log explorer handlers: members only, plus the demo bypass.
* Repository specs: absorb GitSyncSpec and Pkg.GitSpec into CodeContextSpec
Pkg.Git host contracts become two table-driven examples and the opt-in live
smoke test moves alongside them; the GitHub E2E block is dropped (it read
pushes back from the target branch, but export now goes through a PR branch).
Picker-cache, namespace and three export examples fold into their lifecycles;
the blob-cache test uses the recording HTTP interpreter; mockResponse is
exported from Pkg.TestUtils in place of a local copy.
* Name the merged namespace regression; drop the unread GH_TEST_PAT
* Drop setBjRunAtInThePast, orphaned by GitSyncSpec's removal
* web-components: share duration scaling, formatNumber, isDarkTheme and generateId; fold single-use chart and schema modules
formatLargeCount is replaced by formatNumber: identical below 1e9; billions now read 1.5B
(was 1500.0M) and NaN reads N/A. The three duration formats keep their own rounding over
one shared ladder, pinned by a table test of the previous outputs.
* reportProjectUsage: drop unreachable dormant-meter arms and meterIsDormant
The paid arm only runs with a non-empty first_sub_item_id, so a Lemon Squeezy meter
always resolves to the events item; Stripe and NoBillingProvider only yield
non-dormant reasons. Chunking becomes pure; NoSubscriptionItem's doc states the
current rule.
* Golden caches record only on UPDATE_GOLDEN=true
UPDATE_GOLDEN=false enabled live recording because the flag was read with isJust.
Covers the HTTP and LLM goldens, which share withGoldenCache.
* Re-inviting a removed member applies the invited permission
The upsert reactivated the old row without touching permission, so a removed
admin re-invited as a viewer regained admin.
* Free-tier owner is the earliest current membership
The owner subquery included removed rows, so removing a free project's first
member locked every remaining member out (and a downgrade deactivated them all).
The four copies now share Projects.freeTierOwner.
* testServantWithNotifications fails when the handler fails
The Left was hidden behind a lazy fromRightShow, so a caller reading only the
notifications got an empty list from a rejected request. ProjectsSpec's local
evaluate workaround is gone.
* Discord interactions reject replayed timestamps
Discord signs X-Signature-Timestamp but the handler never checked its age, so a
captured interaction could be replayed forever. It now shares Slack's five-minute
window (freshWebhookTimestamp); stale requests get the same 401 as a bad signature.
Merge members, @everyone sync, integrations and API keys into ProjectsSpec,
client metadata into AuthSpec, and the dashboard list/page specs into
DashboardWidgetsSpec. Share httpStatus and setRole via Pkg.TestUtils.
* Bots specs: agent and Slack workflows as lifecycles in BotsSpec
Fold Pages/Bots/WorkflowsSpec, AgenticSpec and BotTestHelpers into
BotsSpec: scenario loops replace per-case its where each case can own
its conversation, channel or request, and a small agent vocabulary
(durable, scripted, invoking, waitingDashboard, rejecting, operationsOf)
replaces the repeated model and fixture plumbing. Tables stay only where
a case advances the clock, deletes members or routines, or polls the
shared job queue. Two duplicated Slack delivery tests are dropped;
setupLinkedSlackData and slackInteraction move to Pkg.TestUtils for
MonitoringSpec.
* Bots specs: restore assertions lost in the lifecycle merge
Label post-revocation replays per origin; recheck deactivation for both
initial transcripts; restore the wiki write body, model-call counts,
one publication identity, the second-channel opt-in, the shortcut ack
body, queued-only wake checks, the Slack destination denial, the full
conversation document count and the Free-plan precondition.
Hoist the repeated repository, receipt, GitHub App and agent-stub fixtures
into spec helpers (initRepo/commit/stagedPatch, recorder, githubApp,
pullRequestApi, refuse/repositoryReview, fixFixture, guest gates), move raw
pool queries onto dbExec/dbQuery/dbOne, and fold the allocation-bridge modes,
review interpreters, webhook failures and the missing-artifact check into
the lifecycles they belong to. Guest-gated cases keep their names and gates.
* CLI: write stdout/stderr as UTF-8 so help survives a C locale
Under LC_ALL=C (minimal Linux images) GHC's handles are ASCII, so help
pages with — or → printed the usage line and exited 1. The binary help
sweep now runs under LC_ALL=C and asserts the non-ASCII lines.
* CLI: metrics query --assert fails when the response does not decode
A response that isn't a metrics result skipped the assertion and exited 0,
so a CI gate built on --assert passed silently. It now exits 1.
* Repository specs: lifecycles per sub-domain
Move every hermetic git-sync example into Pages.CodeContextSpec (per-example DB)
and merge redundant setups into lifecycles: GitHub App install, non-member
mutations, token connections, same-name identity across servers, source-context
pages, overview, configuration folder, ownership with push queueing, and
webhooks. Incident-named guards stay as labelled steps; concurrency specs keep
their real races. Pure plan/YAML/path checks become one table. Pages.GitSyncSpec
keeps only the opt-in live-host smoke and GitHub E2E, as fewer lifecycles.
* Configuration spec: a rejected stale import must leave the local edit in place
* CLI specs: one spec of self-contained lifecycles
Merge CLIBinarySpec, CLIE2ESpec and CLILifecycleSpec into CLI.CLISpec: help
usage, error and list envelopes as tables, binary-vs-live-server walk, one
in-process lifecycle per workflow. withCliBin moves to CLI.Harness. The fake
router honours issues list filters and drops the /log_explorer and
/chart_data arms the CLI no longer calls.
* Log-pattern bulk actions accept ack like issues do
* CLI spec: one binary runner, per-example temp dirs for as-code yaml
* Drop dead telemetrySchemaJson; give the CLI binary spec a UTF-8 locale
The stripped test env dropped CI's LANG=C.UTF-8, so GHC's stdout fell back to
ASCII and help text containing — or → exited 1.
- A monitor re-alerting within an hour of recovering is a flap: its alert,
reminders and recovery go to the Slack thread only, no email/PagerDuty/etc.
- A source keeps one Slack thread per channel across episodes; the first
alert or reminder of a UTC day in that thread is also sent to the channel.
- Unsubscribed error reminders: daily for a week, weekly to 30 days, then stop.
- Issues list defaults to Recently Active, with a deterministic tie-break.
- Query-alert issues keyed by the bare monitor id (migration 0264 backfills).
* Telemetry and infrastructure specs: self-contained lifecycles
Merge Containers, ServiceMap, Telemetry, Exemplars, Prometheus and KqlSeries
specs into Pages.InfrastructureSpec and distill ReplaySpec: typed row
assertions (export the infrastructure row types), fragment goldens for
presentation, per-scenario projects, random replay session ids.
* Move uptime/cron lifecycle to MonitoringSpec; pin exemplar JSON wire
Uptime checks and cron monitors run on a fresh project in MonitoringSpec.
reswapOf and hexId move to Pkg.TestUtils (two specs each). Exemplars assert
the JSON the chart overlay reads again; one metaProject seeder.
A missing, malformed, wrong-secret, stale (>300s) or tampered Stripe-Signature,
and an unsigned, malformed or wrong-secret X-Signature under LS enforcement, are
refused with 400, call no provider and leave the plan and sub_id unchanged.
* Billing and background-job specs: self-contained lifecycles
Merge BusinessFlows, ReportUsage, Reports and the BackgroundJobs/* specs into
BillingSpec and BackgroundJobsSpec (2477 -> 1089 lines). Billing walks onboarding,
settings/storage, Stripe and Lemon Squeezy subscriptions and ReportUsage metering
per project; outbound provider calls are recorded or fixtured. Vague counts pinned
(windows, recipients, member counts); HTML checks become fragment goldens. Replay
POST/GET smoke moves to ReplaySpec. Shard override follows ReportUsage to Billing.
* Billing/background-job specs: exact alert recipients, shared projectOf, dormant-meter doctest
Pin the error-alert sweep's recipients (members + Slack on alert, Slack-only
reminder inside the open incident). projectOf replaces per-spec projectById
boilerplate; fresh replaces repeated session refreshes. Doctest the LS
no-item -> NoSubscriptionItem dormant path. Move the Billing shard override
to the empty shard 4.
* ReplaySpec: accept the warning response's reason field when publishing fails
* ReplaySpec: compare status as aeson Strings
Slack, web conversations, routines and native review/fix jobs share the capability catalog, current authority checks, run ledger and operation receipts. Runs, charts and saved reports open inside the conversation inspector.
Consolidates duplicate regression suites and documentation while retaining the product contracts, native recovery evidence and migration baseline transition.
Validation: all eleven exact-input local checks pass, including 1,216 integration examples (25 pending VM cases), 2,105 doctests, 315 unit examples, 16 CLI examples, 1,041 UI tests and 172 browser tests (one skip). Separate native/KVM acceptance is recorded in the review. The exact Linux AMD64 image was built locally on this Mac with OrbStack/Rosetta.
Merge EndpointDiscovery, SchemaLearning, SchemaLearningPerf, ApiCatalog and
ApiDocs specs into EndpointsSpec (63 examples -> 9, 1885 -> 509 lines).
Scenarios run on example-owned projects; loose bounds pinned to exact values;
docs page asserted on ApiDocsVM plus a swagger-mount golden. Drop the
now-unused createTestSpans and logBackgroundJobsInfo test helpers.
* Ingestion specs: one spec of self-contained lifecycles
Merge GrpcIngestion, TimefusionWriteFailure, StandardOtelSpans,
TraceSessionPropagation, ProcessMessage, KafkaConsumer and ExtractionWorker
specs into Opentelemetry/IngestionSpec (105 examples -> 14, 2723 -> 982 lines).
Counts read through TimeFusion run on example-owned projects.
* OTLP logs: fall back to the batch's sole project like spans do
Logs whose API key arrived only in the gRPC request header (no key in the
resource attributes) passed auth but convertResourceLogsToOtelLogs resolved
no project for them, so they were silently dropped. The spans converter
already falls back to the batch's project when exactly one is resolved
(a6ce1ab7f); apply the same unambiguous-only fallback and empty-key guard to
logs. IngestionSpec now asserts the header-key log lands in its project.
* IngestionSpec: pin exact outcomes the merge left loose
- Unresolvable key: assert the exact poison entry instead of accepting any
poison-or-failure shape.
- SDK redaction: the secret must appear in no stored row, not only rows that
keep the authorization header path.
- Extraction worker runs on its own project (TimeFusion is shared); TF hashes
must all carry a pattern tag; the 3h-old row is never re-driven and mints no
endpoint; session backfill touches exactly the one missed row.
- Kafka mock: one appendRecords seeder replaces seedTopic/seedTopicDue and the
inline folds; reuse the tf helper; pure transforms use frozenTime.
* Log explorer specs: one spec of self-contained lifecycles
Merges LiveTailSpec, FacetsSpec, QueryCacheSpec and ShareSpec into
Pages.LogExplorer.LogSpec; HTML assertions become fragment goldens.
* Log explorer spec: restore exact assertions, share fixtures, rebalance shard
Pins since/window counts exactly, live-tail drop counter, whole-page
negatives, sanitized chart errors and strict pagination indices; hoists
ingestAt/streamChart/hexId; moves Pages.LogExplorer.Log to shard 9.
* BotsSpec: bot specs merged into self-contained lifecycles
Slack, Discord, WhatsApp and agent specs plus their three helper modules
become one Pages.BotsSpec (36 its, was 106). Cross-spec Slack/Discord
helpers move to Pkg.TestUtils; test configs trust the test signing keys.
* Snapshots regenerate with UPDATE_SNAPSHOTS, not UPDATE_GOLDEN
UPDATE_GOLDEN also switches HTTP/LLM goldens to live recording, so
refreshing an HTML snapshot made real outbound calls. BotsSpec review:
shared thread-scoping/history-page/slack-app helpers, exact refresh
assertion, and no race on the forked WhatsApp reply.
* integration-tests: depend on openai for BotsSpec's LLM stub type
* ApiV1Spec and MonitoringSpec: self-contained lifecycles
ApiV1Spec: one walk per resource, an HTTP auth status table, a tenant-scoping
404 table and a pure OpenAPI/MCP contract check. MonitoringSpec absorbs
Pages.MonitorsSpec and IncidentDeliverySpec, drops aroundAll/sequential, and
snapshots the monitor row actions and status badge. goldenParts and tagsWith
move to Pkg.TestUtils.
* ApiV1Spec, MonitoringSpec: restore dropped assertions, trim status golden
MCP protocol and composite-tool calls run against an app that errors if
invoked; compiled scope SQL is asserted on the stored row with a piped
query; bulk failures compared order-insensitively; duplicate message ids
ingested again; muted recovery checks the root's text fallback. The status
golden drops SVG paths and repeated badges (42 -> 4 lines).
* DashboardWidgetsSpec: twelve self-contained lifecycles
87 narrow examples become 12 lifecycles on typed payloads; presentation moves
to fragment goldens. goldenHtml scrubs gzipped widgetZ blobs; withTfChartPool
lets an example that already holds resources use the chart TF pool.
* DashboardWidgetsSpec: snapshot only the fragments under test
elementsWith (TestUtils) slices the elements around given markers, so the
canvas, editor, endpoint-tab and saved-view goldens pin the grid tags,
editor controls, picker and oob contract rather than whole pages
(1.1MB -> 125KB). Restores per-tab variable-bar coverage for the Service
Overview template.
* ErrorPatternsSpec: five self-contained lifecycles with a detail-page golden
Replaces 35 order-dependent examples sharing one database with lifecycles for
extraction, error state, spikes, grouping and notifications, asserting on typed
patterns and issues; the context-rich detail page is a golden snapshot.
* ErrorPatternsSpec: share seedSlackChannel via TestUtils, bg helper, dedupe upserts and canonical query
* ParserSpec: KQL-to-SQL cases as one golden table
22 full-SQL comparisons become rows of one table checked against
tests/golden/kql-to-sql.txt, built from their previous expectations.
goldenHtml now delegates to the new goldenText. AGENTS.md notes the test prelude.
* kql-to-sql golden records which projection each case renders
* AGENTS.md: watcher and sign-off habits that keep iteration fast
284 raw pool checkouts become dbExec/dbQuery (on the test clock), 232
(_, x) <- testServant become call, 20 local nil pids become testPid, and
countIssues, resetSchemaLearning and tablePage replace per-spec copies.
* Issues: lifecycle spec on typed payloads and HTML goldens
Rewrites IssuesSpec as 7 self-contained lifecycles (1505 -> 398 lines, 45 -> 7
examples). Detail and sample handlers return typed views (IssueDetail,
IssueSample) so tests assert on data; presentation is pinned by goldenHtml
snapshots instead of substring greps.
TestUtils gains call/dbExec/dbQuery/dbOne/seedIssue/goldenHtml. Test handlers,
raw fixture SQL and endpoint/anomaly inserts now stamp the test clock, so
snapshots are deterministic. Query-alert threshold logic becomes the doctested
Issues.meetsThreshold.
* Issues pilot: review fixes
Ingestion created_at defaults follow app_now() via migration 0258 (app_now is now an
inlinable SQL function) instead of per-insert edits. Spec helpers for list/view/stamped
calls, queryAlertKey for the stored monitor id, endpoint-trace assertion tightened,
per-constructor ToHtml instances.
* hpack: list migration 0258
* goldenHtml fails on a missing snapshot; document anomaly ordering
* Bump tls to 2.2.2 so Meta Conversions API sends complete the TLS handshake
tls 2.1.13 fails every handshake with graph.facebook.com (HandshakeFailed:
cannot verify CertificateVerify, DecryptError), so each AdConversion job
fails on Meta and never reaches Reddit. tls 2.2.2 connects, and still works
with the pinned crypton 1.0.4; it needs crypton-x509* 1.8 and the
crypton-asn1/crypton-pem forks.
* Package-qualify Data.ByteString.Base16 imports: tls 2.2's crypton-asn1-types brings in base16, which exports the same module
* Test that user SQL reads only its own project on both stores
* Fix tenant scope test compile
* Scope user SQL to its project at every tenant table, on both stores
The executor's only tenant boundary was a check that project_id='<pid>' appeared
somewhere in the statement, so '... OR TRUE' read every project. scopeUserSql puts a
CTE filtering each tenant table by project_id ahead of the statement (spliced into its
own WITH so ORDER BY holds): bare names are shadowed, which Postgres and DataFusion
both resolve ahead of the table, subqueries included; allow-listed qualified tables
are renamed to their CTE. It refuses comments, WITH RECURSIVE, other schema-qualified
or 3-part names and non-tenant public tables. Applied in executeSecuredQuery and the
raw chart path.
* Inline tenant CTEs on Postgres, keep template SQL with comments scoping
NOT MATERIALIZED on Postgres so a table read twice keeps the statement's time filter
in each scan (EXPLAIN shows no CTE Scan); comments are dropped by the tokenizer rather
than refused, since shipped templates carry them. Every template statement is checked
to scope on both stores.
* Test that /chart_data runs client SQL only for project editors
* Run browser-supplied SQL only when the server signed it, or for editors
/chart_data and /p/{pid}/widget ran whatever SQL the request carried, guarded only by
a project_id substring, so any viewer or the anonymous demo guest could hand them a
statement. Every SQL the server renders (dashboard widgets, variable pickers, issue
rollups) now carries an HMAC (Widget.sqlSignature) the browser echoes back; unsigned
or altered SQL runs only for a project editor previewing their own.
* Type the SQL signature comparison; drop a redundant import
* Probe the SQL cache with a sequence instead of reading query_cache
The cache tests observed hits by having a raw SQL widget count query_cache rows, a
table user SQL may no longer read. A sequence advances on each real execution, so a
cache hit still shows as a repeated value.
* Apply hlint suggestions in scopeUserSql
* Treat comments as whitespace around a dotted name
'users/**/.users' is users.users to Postgres, but the tokenizer split it in two and
the qualified-name check never saw it. Comments between the parts of a name are now
skipped like spaces.
* Preserve entered saved-view names and adopt views in Overview
* Make frontend timing checks stable under parallel CI
* Keep filter-free dashboard tabs empty during navigation
BodyWrapper loaded gtag.js for AW-11285541899 on every page in production,
outside the consent gate; externalHeadScripts_ already loads the configured
GOOGLE_ADS_CONVERSION_ID with consent, so the hardcoded tag and its config
call go. The LemonSqueezy checkout conversion now sends to the new
GOOGLE_ADS_PURCHASE_LABEL (skipped when unset) with the order id as the
transaction id, instead of a hardcoded label and an empty id.
* Saved views: edited state, shared menu for Issues, overflow-safe dashboard tab row
- Picking a view carries view=<name>; once the variables drift the bookmark
shows a dot and the menu marks the view edited. The menu re-renders on
variable changes (not on auto-refresh) and morphs, so it stays open.
- savedViewsMenu_ in Pages.Components now backs both dashboards and Issues.
- Dashboard tabs scroll sideways; past four variables, unset ones after the
third fold behind +N (CSS only).
- log-list-bugs: drain the mount health check by frames, not a 50ms sleep.
* IssuesSpec: assert the shared saved-views menu and its active state
* Test that /chart_data_shot is not served
* Remove the unauthenticated /chart_data_shot route
A leftover from before signed PNG export: it sat outside every auth layer and ran
the caller's KQL or raw SQL against any project id it was handed.
* Escape dashboard variables in query templates; harden local CI and dev tooling
Security
- Dashboard templates quote request variables ('{{var-x}}' in SQL, "{{var-x}}" in
KQL) but received them verbatim, so a quote in a URL value ended the literal and
the rest ran as SQL. fillQueryTemplate now takes the template language and escapes
var- values for it, once, where text becomes a query (maps stay raw, so the cache
key path that re-feeds presets no longer double-escapes). Server presets are
merged after request params, so a request can no longer re-point project_id or
time_filter. Variable/constant KQL queries use the KQL presets.
- Bump overrides for dompurify (^3.4.17) and tmp (^0.2.6), pin katex for
micromark-extension-math, and override @babel/core and postcss-selector-parser;
root lock regenerated with npm 10 (npm 11 drops bundled optional deps and breaks
npm ci).
CI / dev
- Local CI builds its Linux chart-cli to a container path (CHART_CLI_PATH) instead
of overwriting the host's native ./chart-cli through the bind mount.
- scripts/e2e.sh refuses a server binary older than the Haskell source.
- Watchers restart ghcid when it gives up after a branch switch, and log it.
- hpack-check runs before ci-signoff.
- Integration shards record their exit status; a shard that crashes after a
clean summary is now reported with its signal instead of skipped.
- Heavier widget-drawer e2e tests get test.slow() and longer inner waits.
Cleanup
- Weekly report chart URLs are Maybe Text end to end (no "" sentinel).
- tab.slug is the single tab-name slug rule.
- streamFrames/completeFrame live in TestUtils; specs render via renderT.
* Pass the template language in DashboardTemplatesSpec
Captures ad click IDs (consent-gated), stores them on new accounts, and reports signup and activation to Google Ads (browser + offline-upload view), Meta CAPI and Reddit CAPI v3 via an AdConversion background job, off the login path.
- Slack and Discord bot replies, /dashboard shares, and report alerts omit the
image block when the chart URL is too large to sign, instead of posting
image_url "" (Slack rejects it). dcGallery moves to Pkg.Mail, emits no
component without charts, and puts description beside media as Discord expects.
- Metrics pages treat blank since/from/to (a cleared picker) as absent, taking
the default window instead of collapsing datapoint counts to now..now, and
stop propagating empty params into counts/page URLs.
- Removing one dashboard tag filter rebuilt the URL by substring replace on the
bare list path, dropping every other filter and the sort; links are now built
from the current sort and remaining tags.
- Drop two unused imports in BackgroundJobs.
* Distill dashboard saved views, widget rendering, and their tests
- widgetPngUrl returns Maybe Text; stampPngUrl replaces three repeated
empty-URL guards (widget post, dashboard widgets, log explorer)
- inline single-caller helpers into their callers' where clauses
- shared renderT test helper; consolidate repeated spec assertions into
shouldContainAll/for_ loops without dropping coverage
- titleToFilePath cases live in its doctests instead of GitSyncSpec
- list 0256_ai_artifacts.sql in monoscope.cabal (hpack)
* Route dashboard URLs through dashboardUrl and type widget monitor dashboard ids
* Live Tail: keep following the newest rows when they are tall
The virtualizer's remeasure scrolled the list short of the bottom, and that
scroll read as the reader leaving, so following stopped for good. The list now
pins its last row (held through remeasures) and only the virtualizer's
'unpinned' event, raised for a reader's own scroll, stops following. Replaces
the frame-and-layoutComplete follow loop.
* Live Tail restarts on a submitted query, not on every typing pause
A restart clears the rows, so the editor's 500ms typing debounce wiped the stream
while the reader was mid-query. The editor now marks debounced emits as
source: 'typing'; Live Tail waits for Enter, AI search or a programmatic edit.
* AI documents: cap per conversation, keep both ends of long reads, skip unused queries on document refresh
* Dashboard saved views move into a bookmark menu beside the variables
Drops the separate Views row; the menu lists views, saves the current
one and clears filters. Clear filters only shows when a variable has a value.
* fmt (fourmolu 0.19)
* Live Tail: stop freezing weaker machines under load
The Fields picker re-sorted and re-rendered every known field on each row
batch (87% of the main thread at 4x CPU while open); it now renders only
while open, from a snapshot, capped at 200 with search for the rest.
Rows are parsed only when mounted, flattened once in linear time, and
published at the server's 250ms drain cadence, never in hidden tabs.
Unchanged rows skip re-rendering and keep their zebra parity on eviction.
At 6x CPU: main thread blocked 7.8s/8s -> ~1.7s, editor typing p50
125-150ms -> 21-34ms. bench/live-tail.* reproduces the load.
* AI agent documents: save_artifact/read_artifact beside conversations and routines
Agents keep markdown documents per web conversation (apis.ai_artifacts), keyed by
a validated slug. Scheduled routines append one section per run to a dated daily
document in the project's time zone. Threads list documents beside the chat with a
heading outline; an open routine document refreshes every minute. Saved-document
chips read the key from the tool result's structured data, not its message text.
Routine templates describe their inputs as typed signals, and assistant-only
routine results now render.
Live Tail: a field toggle re-sorts the open picker instead of rescanning the buffer.
* Live Tail: handle the virtualizer's disconnected layoutComplete rejection
lit-virtualizer rejects layoutComplete with 'disconnected' when torn down;
following the live edge awaited it unguarded, so Clear, a restart or leaving
the page mid-follow raised an unhandled rejection.
* Disconnect session-list fixtures after each test
Lists left mounted kept polling for charts after the file ended, so a timer
could fire against a torn-down jsdom and fail the run.
* Disconnect test fixtures at the end of every vitest file
Components left mounted (LogList's chart poll) fired timers after jsdom was torn
down, failing the run with 'window is not defined' under load. Supersedes the
per-file fix for the sessions spec.
* Artifact keys never end in a hyphen after truncation
* chore(deps): bump jsdom from 29.1.1 to 30.1.3 in /web-components
Bumps [jsdom](https://github.com/jsdom/jsdom) from 29.1.1 to 30.1.3.
- [Release notes](https://github.com/jsdom/jsdom/releases)
- [Commits](https://github.com/jsdom/jsdom/compare/v29.1.1...v30.1.3)
---
updated-dependencies:
- dependency-name: jsdom
dependency-version: 30.1.3
dependency-type: direct:development
update-type: version-update:semver-major
...
Signed-off-by: dependabot[bot] <support@github.com>
* Unmount log lists after each failure-state test
jsdom 30 tears down requestAnimationFrame with the window, so a batch
timer left by a still-mounted list fired into a missing global.
---------
Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Anthony Alaribe <anthonyalaribe@gmail.com>
* Issues: responsive log details, API change service labels, code context cleanup
* Simplify review fixes: fix unparsed hyperscript in trace divider and review rows
* Match htmx 4 HX-Target on dashboard tabs; align tests with the redesigned repositories and issue pages
* Close the review dialog on rerun; align repositories e2e with the table view
* Align repositories e2e with the shared empty state and tab navigation
* Host map e2e: the inspector drawer is modal
* Highlight the selected visualization tab with brand colors
* Add RUM audience breakdowns, investigation filters, and saved segments
* Declare form decoding dependency for integration tests
* Check expanded RUM templates for query scoping
* Supply required summaries in RUM browser fixtures
* Prepare shared npm dependencies before parallel CI lanes
* Target the segment disclosure explicitly in browser coverage
The vite group's "vite*" pattern also matched vitest, so vitest and @vitest/browser
landed in different groups and each major bump failed to install alone (#723, #727).
Root jest had no tests of its own; it only picked up web-components' vitest files.
* Share Explorer facets and infrastructure table controls
* Verify shared controls across namespaces and responsive layouts
* Remove orphaned time inputs and await browser state
* Classify facet content exhaustively
* Consolidate inventory defaults and overlapping regression scenarios
* Share Clear all across facet rails and demote facet glue to CSS
Clear all lives in the shared rail for both Explorer and inventories and only shows
while a facet is ticked. Column choices restore without a sync event, filter inputs
skip re-filtering swaps while empty, and the collapsible rail opens on desktop via
::details-content instead of a resize script.
* Cover Explorer facet Clear all end to end
* Clear facets through their own checkboxes; re-filter swaps only while searching
* Skip the facet Clear all e2e quickly when the fixture has no facet values
* Distill grouped rendering and align facet controls with selection semantics
Panes are tracked per worktree+job in session options, so any window
reuses them instead of opening a new window. Adds tmux-minio-local.
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Since a7ece43bc made the hourly per-project jobs actually run, ErrorSpikeDetection
loaded error_data for every open pattern: 4.3 GB of JSON for the self-monitoring
project (HasqlException messages embedding whole SQL statements, up to 21 MB a row),
overflowing the 14G heap and restarting a replica at ~:01 most hours since 10-22.
The query no longer selects it (nothing used it), and stored message/root message/
stack trace are capped so a pattern can't grow that large again.
Choosing Free in the plan picker cleared sub_id but never cancelled the Stripe or
LemonSqueezy subscription, so the customer kept being billed for a plan they left.
Review follow-ups: hashes are no longer computed for rows sampling drops; the banner
rounds the ratio and appears from about 1 in 2, so 99% kept no longer reads as
'1 in 2'; note that metrics share the events pool.
* Sample free-tier ingest across the day instead of cutting off at the cap
A capped project used to keep everything until 10k events, then nothing until
00:00 UTC. Now each pool keeps with probability (budget left) / (traffic still
expected today), paced from yesterday's hourly shape or the last hour's rate, with
20% of the budget reserved for errors. Decisions hash the trace id (or record id,
or metric series), so a kept trace or series stays whole; kept spans and logs carry
attributes.monoscope.sample_weight. Counters live in projects.ingest_sampling. Past
1.2x the budget nothing is kept and the OTLP edge rejects with partial success, as
before. The banner, notices and emails say 'sampled' instead of 'dropped'.
count() does not yet sum weights; that touches KQL compilation, rollups and monitors.
* Key free-tier sampling by project text and keep pacing policy pure
Review follow-ups: uncapped records in a mixed batch cost one lookup; metrics reuse
metricSeriesId as the series key; the error reserve and ceiling move into
Pkg.Sampling.rates with doctests.
* Keep error traces whole and make sampling counters best-effort
Review follow-ups for free-tier sampling:
- a key with any error in the batch is judged at the error rate, so a trace with an
error span is kept or dropped whole
- a counter write failure is logged, not thrown, so it cannot fail the ingest batch
- counters are one row per (project, hour, is_error) with seen/kept, halving the
schema, the tally SQL and SampleCounts; an hour index serves the daily cleanup
- Pkg.Sampling.rates also takes the hourly meter, so both caps live in one pure place;
ceiling is renamed hardCap
- the weight is stamped with the module's lodashMerge pattern
- tests: error traces kept whole while the rest is thinned, metric series kept whole
* Cheaper weight stamp, documented per-batch wholeness, clearer DLQ guard
Review follow-ups: stamp the weight into the monoscope key only; note that trace
wholeness and pacing are per batch / approximate; doctest an exhausted error
reserve; drop the magic hash range; name the resolved projects in the DLQ guard.
* Ack capped OTLP payloads instead of dead-lettering them
A payload whose every project resolved but is over the free-tier cap converts to
zero rows by design. The unresolved-project guard treated it as lost data and sent
it to the DLQ, which redelivered it through every retry tier: ~10k attention logs an
hour since the cap started tripping on 2026-10-22. Unresolved keys still DLQ.
* Dead-letter capped payloads that also name an unresolved key
Review follow-up: a zero-row payload is a deliberate drop only when every key it
names resolved and every project is capped; a mixed payload is lost data again.
* Dead-letter any payload naming an unresolved API key
Simpler and general: one unresolved key poisons the whole payload, so a payload
mixing it with a capped (or any resolved) key no longer loses the unresolved part.
Rows left out on purpose come from resolved keys and are acked.
* Pin the 0.05 case and say why only API keys can fail to resolve
Review follow-ups: fmtPct1's doctest keeps the half-to-even 0.05 case it exists for;
the poison comment is trimmed to its invariant and notes that at-project-ids always
get a cache.
* Keep the zero-rows safety net for uncapped projects and check at-project-ids
Review follow-ups: a payload is dead-lettered when it names an unresolved key or an
at-project-id with no cache, or converts to zero rows unless every project it names
is capped; only deliberate cap drops are acked.
* State the ack condition once: every project resolved, and rows or a cap
Review follow-up: traverse the key lookups instead of comparing lengths.
* Allow promotion codes at Stripe checkout
* Keep positive rates off 0.0% whatever showFFloat's rounding
fmtPct1 promised positive rates never round to zero, but its 0.05 threshold assumed
half-up rounding; showFFloat rounds half to even, so 0.05 rendered 0.0% and the
doctest from #713 failed. Key on the rendered text instead.
Combine the functional changes from #612, #556, #712, #557, #559 and #526. Keep the sessions PR's unrelated Slack plan out of this train.
Require complete invoice reads, confirmed payment and retryable settlement for Stripe reactivation. Cover the failure paths through signed webhook and checkout handlers.
* Share local CI dependency caches across checkouts
Each checkout path got its own cabal/npm/playwright volume set, so every
worktree and signoff clone leaked ~8GB of content-keyed caches; 35 sets had
piled up. Share those. dist-newstyle stays per checkout: sharing it was tried
and weeder then reported live functions as dead, because unchanged modules
lost their .hie files after another branch built into the volume.
* Note that local sign-off must stay fast
* Share dist-newstyle across checkouts; weeder repairs missing .hie files
After another branch built into a shared dist, GHC can leave a live module
compiled without its .hie, so weeder misses every reference it makes and
reports live functions dead. The weeder check now recompiles any tracked
module missing one (dropping cabal's build stamp, since a touch leaves the
source hash unchanged) instead of every checkout paying a cold build.
* Fold Real User Monitoring into the RUM dashboard and the Explorer sessions view
The /rum page duplicated what rum.yaml and the Explorer already do, and the two
had drifted: the template filtered on telemetry.sdk.language, which no browser
SDK sets, so it showed nothing in production.
- rum.yaml carries the page's browser/page-view/error predicates verbatim (so
TimeFusion rollups still serve them), route-masked top pages, sessions,
errors, a single-scan audience table, and Web Vitals P75 read from histogram
buckets in portable SQL (Postgres and TimeFusion), never the export mean.
- Tables gain hidden columns and link placeholders for every row field and the
dashboard's time range; table cards render their call-to-action link.
- /rum opens the dashboard; /rum/sessions opens the Explorer sessions view over
browser telemetry, from the sidebar and the dashboard alike.
- Deleted the page, its model, caches, CSS, specs and e2e; withSharedCache
moves to Pkg.QueryCache for Endpoints.
* Keep /rum/dashboard as an alias of the RUM dashboard entrypoint
* Read unset dashboard variables as empty; fold the sessions header's service scan into the session grouping
An unset {{var-*}} stayed literal in widget queries, so the RUM dashboard's
"no application selected" branch never matched and every widget read zero on
a first visit. replacePlaceholders now empties an unset dashboard variable.
The Explorer sessions view forked a second full-window scan just to count
services for its header; aggregating each session's services in the session
scan costs ~5% of it (4.0s vs 4.2s on prod demo, 24h), and the page context
query no longer needs its own service list.
* Let dashboard tables explain themselves on hover
Columns gain a header description and a per-cell tooltip templated over the
row, both through the body-wide tippy handler long cells already use. The RUM
dashboard spells out every Web Vital abbreviation, P75, the known range and
its other terms.
* Restore what the RUM page showed beyond the dashboard
- Web Vitals with nothing in the window get a row saying so instead of
vanishing; thresholds and descriptions live in one VALUES table.
- Mixed histogram bucket layouts (the browser SDK moving to threshold-aligned
buckets) coarsen to the edges every point shares: each point's cumulative
count is summed per edge, which is exact there, instead of interleaving
bucket counts from different layouts.
- Screen recordings whose spans never arrived join the Explorer sessions view
again when it is unfiltered or browser-scoped, with their Replay action;
they carry no attributes, so any other filter or scope leaves them out.
* Load browser SDK 0.13.0 for Monoscope's own telemetry
0.13.0 exports web vitals as DELTA histograms with threshold-aligned buckets,
so the RUM dashboard can rate CLS and the other vitals from their P75 bucket.
Replaces the vendored 0.11.6 bundle.
* Address review: template-only variable clearing, one predicate source, tested redirects
- fillQueryTemplate clears unset {{var-*}} in a dashboard query template before
substitution, so a substituted (telemetry-controlled) value is never rewritten;
replacePlaceholders is back to plain substitution for links and tooltips. It is
the one entry point for chart, logs-widget, variable and constant templates.
- RUM's predicates are built-in placeholders ({{browser_filter}},
{{pageview_filter}}, {{error_filter}}, {{browser_kql}}) from Pkg.Parser, so
rum.yaml, endpoint-stats.yaml and the Explorer link cannot drift; a test pins
that the SQL and KQL forms select the same rows.
- /rum, /rum/dashboard and /rum/sessions are one route; links shared from the
old page (?tab=sessions&session=…) open that session; unknown paths 404.
Links keep the window via timeScopedUrl / TimePicker.rangeQuery.
- Recording-only sessions are decided inside fetchSessions from the parsed query.
- KQL embedded from SQL strips backslashes as well as quotes; cell tooltips carry
aria-description.
- Tests for every Web Vitals rating branch, the redirects and withSharedCache
miss/hit/expiry.
* Parse endpoint widgets with the real browser filter in the template test
The image job took ~66 min because CI almost never found a prebuilt
image: local sign-off built it emulated (slow, and it crashed the local
Docker), and the fourmolu bot ran a different version than laptops, so
it rewrote signed-off trees and changed the image's tree fingerprint.
When CI did build, the dist-newstyle cache mount died with the runner.
- Default the image builder to the native amd64 builder when it exists.
- Pin fourmolu in the Makefile for both laptops and the bot; sign-off and
ship refuse an unformatted tree.
- Carry dist-newstyle across runners via the Actions cache (master saves,
PRs restore read-only).
2026-10-24 13:24:16 +02:00
722 changed files with 96792 additions and 64727 deletions