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.
2026-11-04 22:35:35 +01:00
584 changed files with 44871 additions and 40609 deletions