All notable changes to Insider will be documented in this file.

The format follows Keep a Changelog, and releases follow Semantic Versioning.

[Unreleased]

[0.1.0] - 2026-11-17

The first release on Hex.

Added

  • Hex packages. insider (the core) and insider_lab (the observer CLI, the Mix tasks and the escript) carry a description, the MIT license, and links to the source, this changelog and their hexdocs. Hexdocs source links point at the release tag. Install the CLI with mix escript.install hex insider_lab. The welcome quick start, its tandem.escript and transports.observer entries, and the observer's --help name that install next to the checkout route. In this repository the Lab still builds against the core by path. INSIDER_LAB_HEX=1 builds its package, which depends on insider from Hex. The Lab package ships its own copy of the license and recon's BSD-3-Clause notice.

  • A tag-triggered release workflow (release.yml) publishes both packages through a Hex workload identity, in a GitHub release environment with required reviewers, with no stored key. The first release is published by hand. docs/development.md "Releasing" has both procedures.

  • Project license and community files: LICENSE (MIT), CODE_OF_CONDUCT.md (Contributor Covenant 2.1), SECURITY.md, and CONTRIBUTING.md, linked from the README "Community" section. LICENSE names its copyright holder. SECURITY.md responds on a best-effort basis with no fixed response times, and a 90-day default disclosure embargo. Conduct reports and private vulnerability reports go to the shared open-source mailbox, opensource@clarity.com. Contributions carry a Developer Certificate of Origin sign-off (git commit -s), and a pull request discloses AI assistance in the template's new "AI assistance" section. Bugs and proposals go to GitHub issues.

  • Live pairing chart: a picture of the session for the programmer an agent pairs with. Observer chart writes one self-contained HTML file (inline SVG, no script, a CSP that allows none, every string escaped, mode

    1. and prints its path: a headline (the most notable change and how long after the mark before it), requests, latency p50/p95, waits before the endpoint, errors by signature, the longest mailbox, memory and evictions on the local wall clock, marks as lines, the window since a mark shaded, the digest's anomalies as numbered markers, and the digest's lead lines. --serve serves it on 127.0.0.1 at a random token, refreshing every second (wrong Host 421, non-GET 405, no CORS), until --for (default 30m) or the session ends. It renews no lease, its first read included (the new read option "renew" => false), and reads the window again when the host narrows the profile. The page says what it could not read (past 20,000 events, an early-stopped digest, evictions). An existing --out path, a symlink included, is refused. It reads with its own reader through the session's disclosure. The welcome's pairing recipe starts with it. The idea is credited to Orion (https://github.com/LivewareProblems/Orion), whose live latency chart inspired it. No Orion code is used.
  • Live observer smoothness (observers rated Insider 5.0 useful but 3.5 smooth, with 13 failing command lines across 6 runs). A read without --session reads the node's active session (stop, amend and otlp-receive still need it); --reader is accepted on status, welcome, capabilities, handoff, renew and marks; --trace is --trace-id; help OPERATION ignores appended target flags; a flag an operation does not take names the operations that do (accepted_by). Compact batches add # lost: (evicted events, why, and whether the first event shown is not the one after the cursor) and # more: (the bound that cut the read, the cursor to continue from, and its maximum); trace and timeline text say the same when cut, and every Lost: line says why events were evicted and what keeps them.

  • Live repeated query shapes (two of three runs found the right spans and still blamed another repeated query). trace groups a request's Ecto queries by table and statement shape, never parameters, across the whole tree, with the caller (Ecto's repo stacktrace, else the parent span, else unknown, saying which) and the total time, and leads its text with them (order_items × 25 from MyApp.Orders.fetch/2, 31 ms total). The digest lists them per trace and adds an n_plus_one anomaly for one shape repeated 10 times or more in one request.

  • Live Oban job events are readable (every run decoded Oban's args by hand). oban.job.* events carry attributes.oban (worker, queue, attempt, state, args keys) in every profile, and in the rich profile payload.oban_args, the args with Oban Pro's term- values decoded when read (binary_to_term with :safe, never a compressed term), masked and bounded; the emitting process does constant work. Trace, timeline, and compact lines show them; Oban job spans show the worker, queue, and attempt.

  • Live pairing marks: an agent watching while a programmer acts in the app no longer guesses times or cursors. mark (--label 'about to click Confirm', --reader) records the moment as the newest receipt, its time, label and reader, and a live.mark event; its reply's next is the command to read since it. digest, trends and timeline take "since" "mark" or "mark:LABEL", and events_since/3 the same as its cursor (observer --since-mark [LABEL], in place of --since or --cursor): the digest's Window: line says since mark 'LABEL' (HH:MM:SS UTC, N s ago), never counts marks, and says when nothing was recorded since the mark. marks (--human) lists them. Labels are one line, credential-masked in every profile (strict keeps marks), and cut to 120 bytes (a label, or a lookup label, past 1,024 input bytes or not valid UTF-8 is refused before any work); a session keeps its newest 256 marks through amendments and after a stop. An unknown label is the new error mark_not_found, which lists the newest labels. The welcome quick start and a pairing recipe say how.

  • Live known-normal baseline (most of the digest's anomalies were known dev noise that hid the new one). baseline --session S [--since latest-5m] marks the current candidate anomalies normal for the session (kinds, hashed identities, and counts; never names or values); later digests and status fold each candidate against it before choosing the top one ("2 known-normal anomalies hidden (baseline set 14:02; --show-baseline)") and lead with what is new. One at 10x its rate (compared unrounded) comes back, saying so; a crash loop's reason is part of its identity. --show and --clear read and remove it; digest --show-baseline lists the hidden ones. Each anomaly has an identity and a count.

  • Live digests leave an observer's own requests (/tidewave, Tidewave's MCP calls) out of the request waits and bursts, count them in requests.observer, and say so once.

  • Compact GraphQL lines keep the decisive fields: an anonymous operation is named by its top-level fields, and the line adds types=[…] and, in the rich profile, args= (bounded, masked), actor=, client=, and the trace id, so --format full | jq is no longer needed for them.

  • Live changes: who changed an in-memory value (a dev feature flag was flipped by another user's request, and its store kept only its current value). Start option watch_writes (--watch-write MOD.FUN/ARITY, with the calls component) traces a store's write functions within the call-trace bounds, recording each write's key (and, rich only, its value; strict copies only the key out of the caller). changes --key K names each write's writer from one request of its own process (its process, GraphQL operation, route, user agent, user id (rich), and trace), or says it is unattributed. A value under a credential-named key, or a secret-shaped value, is recorded as [masked: N bytes]. The digest's anomalies add value_changes, a key written more than once and by whom ("at least N" when writes were evicted or not examined).

  • Live kept mutation records. A session with the telemetry component keeps a compact record of each GraphQL mutation (operation, result, error counts, trace, process, time) in a ring of 4,096 apart from the Recorder, so a flood cannot evict what a mutation did; status counts each loss (dropped, missed_receipts), kept records pass the reader's view, and trace names the kept mutations it does not show, and whether their events were evicted.

  • Live kept mutation records name the client and the response types, and list by record id. A rich session's absinthe.execute.operation.stop carries graphql.client (the request's user agent and remote address, remembered from Phoenix's endpoint start); each kept record adds user_agent, typenames (a ValidationError inside a 200 reads result=ok types=[ValidationError]), and ids from its arguments; mutations [--id ID] [--human] lists them.

  • Live keeps the traces of mutation requests by default: with the telemetry component, the trace of a request that ran a GraphQL mutation is retained without --retain-traces (at most 16, with a 1,024-event lookback for its earlier events; losses counted as lost and evicted_traces). The default never costs what --retain and --retain-traces keep: past the bounds mutation traces go first, and a trace the automatic pool lets go keeps its events in the lookback.

  • Live trace --values shows a mutation's inputs (rich only): the current mutation's converted arguments by schema name, credential-masked and bounded as the response values, under arguments., selectable with --values-path.

  • Live digest and status lead with anomalies. The digest's anomalies rank request bursts, pre-handler waits from 1 s, error spikes, restart loops, mailbox or run-queue pressure, and evictions, one line each with the next command, and --human prints them right after the first line. A burst in a window with evictions says other bursts may be missing, and an evicted window says a burst among the lost events is not counted. status adds the last minute's anomalies without renewing the lease. A read that sets or clears a reader's stored view says so (view_note, compact # note:), and a --human digest through a stored view that hid events says so on its second line with --view-clear. Before this, a burst line was read about 10 minutes late, and a sticky view hid 1,266 events. The digest's text no longer has separate Pre-handler waits: and Request burst: lines; the anomalies replace them.

  • Live request waits and bursts. Each request's wait before Phoenix's endpoint telemetry began (in dev the code reloader and the plugs before Plug.Telemetry) is paired from bandit.request.stop (or cowboy.request.stop, both new quiet defaults) and phoenix.endpoint.stop: the digest's Pre-handler waits: line names the slowest, and trace and timeline add a Wait: line. The digest's Request burst: line flags arrivals far over the usual rate with their top sources (user agent or address in the rich profile) and the requests they overlapped. New welcome recipe "app hangs", which says Insider's inspection works over distribution while the request path is stalled. Before this, hangs took 11.6 minutes to place and nobody linked them to another client's bursts.

  • Live per-trace retention. trace --retain pins a trace: its events the Recorder still holds and every later one are kept apart from the Recorder and survive its eviction. --retain-traces N (start or amend) keeps the N most recently active traces. Bounded (8 pins, 4,096 events, 4 MiB) with every loss counted; trace reports retention (kept, restored, lost, missed) in its result and a Retained: line, and the first read of an evicted, unkept trace says how to pin one. Before this, a trace came back empty after 35,263 evictions.

  • Live trace --values (rich profile only; strict refuses with disclosure_denied): the trace's GraphQL response data as credential-masked, bounded path = value fields, narrowed with --values-path. The rich absinthe.execute.operation.stop payload records the response data (graphql_data) instead of a rendering of the blueprint. Diagnosing an API contract mismatch needed the numbers.

  • Live GraphQL outcome on spans and Telemetry events. A GraphQL error inside an HTTP 200 was invisible. Absinthe's absinthe.execute.operation.stop (now a quiet default when Absinthe is loaded, recorded at any duration) and the operation's span carry attributes.graphql: operation name and type, result (ok, user_errors, partial, errors), error count, codes and paths, and a payload's validation error count, fields and types; never messages or values, and only the type, result and counts under the strict profile. GraphQL errors are severity error and payload validation errors warning; the digest's error_signatures, the trace text, and compact lines show both. New welcome recipe "GraphQL error in a 200".

  • Live trace --human prints the span tree as text: each span under its parent with its duration, status and GraphQL outcome, and the events joined to it. "collapse" (--collapse sql,auth) folds each run of matching siblings into one counted line and "hide" (--hide) drops matching spans and events; both take sql, auth, or a name prefix, and omitted counts them, so an 844-span trace reads in a screen. The observer's trace --human and timeline --human print the text alone, not the JSON around it.

  • Live compact otel lines show the span's name, kind, duration, status, GraphQL outcome, and trace id; they showed only otel.span info PID. The digest's new shared_readers hint says, when sources evicted while two or more readers share the session, that they share one Recorder and how to keep it (digest and trends, summaries, views, reading often); the welcome's lost-events and several-agents recipes say the same.

  • Every Live read takes a reader, and each reader has its own view. digest, trends, trace, and timeline accept "reader" (--reader NAME) like events and watch, and list the reader in status. A view given with a reader becomes that reader's own view for its later reads (--view-clear clears it); status.readers[] shows it. New view keys: exclude_signatures (--view-exclude-signature: a digest signature id, a supervisor reason_fingerprint prefix, or a module name, such as an environment's known JWKS crash loop), and services, routes, and traces (--view-service, --view-route, --view-trace), which keep whole traces across services, resolved from the services and routes of the newest 4,096 ingested traces. Digest error signatures carry an id. Results say which reader and view they were read through and what the view hid (filtered.view.exclude_signatures, filtered.view.scope, filtered_view). Views never change what is recorded.

  • Live digest covers the last minute by default. "since" takes "latest-DURATION" (whole ms, s, m, or h, 1 s to 24 h) and defaults to "latest-60s": the window starts at the first event the Recorder admitted that recently. Admission times follow receipt order (an event's own wall_time may not: a Logger call can pass its own time), so the start is found by a binary search of owner probes that read past withheld receipts and neither renew the lease nor keep a cursor baseline. A probe that cannot decide is taken as recent, so the window may start early (start_exact false) but never drops a recent event; a search the budget cannot finish is a timeout. A digest without --since no longer reads a long session from its start and, out of budget, reports minutes-old history. trends keeps its session-start default and accepts the same values. The digest window carries since, from_wall_time, start_exact, as_of, and age_ms; the human text adds a Window: line (what was asked for, its start, end, and the newest event's age) and a staleness line for an old window not limited in time; each hint carries the window it was worked out over, and its Next (receipts A-B, the last 60 s): line says so.

  • Live welcome names the tools that pair well with Insider. Both welcome forms carry pairs_with: Credo, Argus, recon, Tidewave, and observer_cli (for humans, not agents), each with when to use it, how to tell it is there, and how to run it; runtime.pairs_with_available reports which the node has: an already-loaded module (including one --load pushed, which is not on the code path), a beam on the code path, or an executable on PATH; detection loads and runs nothing. mix insider.live --help and the agent guide list the same tools.

  • Live next-command hints. The digest's "hints" (and one Next: line each in --human) give the exact command to run next, with its reason and counts, as observer command and as amend/2 options: for a crash loop or repeated exception, trace_calls, the amend --component calls --calls MOD.FUN/ARITY --calls-results exceptions that records the failing call, with the function taken from the crash's stack (call_candidates) or the crashing child's GenServer callbacks and the session's components kept, or, before OTP 28, trace_calls_unavailable with the :recon_trace.calls/2 call to run by hand; and for each source the Recorder evicted over its share, the amendment that stops it (reduce_logger with --logger-summary, reduce_telemetry with --telemetry-summary, reduce_poller, and raise_capacity) with the per-source counts from recorder.sources. An events batch that shows a crash or exception carries the same call-trace hint, and --format compact prints it as a # hint: line. The welcome's crash-loop recipe leads with the call trace, and a new "lost events" recipe covers evictions. Only Logger messages are suggested for a summary: a flood of reports (never summarised) gets a logger_reports hint without a command. Functions are compared as --calls resolves them, so an Elixir.-prefixed or quoted-atom spelling never yields a duplicate the session refuses.

  • Live digest separates Insider's own footprint. vm.target holds the node's processes, process memory, and ETS without Insider's own, and --human prints them that way, with Insider's own beside them and the port count, instead of attributing the Recorder's table to the application.

  • Live trends of Poller evidence and compact Poller lines. trends adds "poller": per-sample series of binary_bytes and port_count (vm_sample), ports per type (port_top), and mailbox length per ranked or watched process (process_top, process_watch), each with its unit, first-to-last change and direction, growth per minute (per_min), maximum, and points; --kind vm_sample|port_top| process_top|process_watch narrows to them. --format compact now prints ets_top, port_top, process_top, process_sample, process_watch and poll_cycle content (rankings as name:value), where ets_top and port_top printed only -, and vm_sample adds port_count and binary_bytes. New welcome recipe "growth over time".

  • Live summary exemplars, trend windows and Logger bursts. Each Telemetry summary names up to three of its interval's slowest events and its first error as "exemplars" (receipt, roles, duration_us, error), recorded in full just before it, so events --cursor RECEIPT-1 --limit 1 opens the actual event; candidates come from the values of the emitting process's one counter update (at most 4 per histogram bucket). The interval's first error takes a reserved path, not the shared inbox, so it is kept whenever it reaches the collector. Summaries carry "window_started_at", "window_ended_at", "exemplars_lost" (the interval's candidates lost: inbox full, normalisation failed, recorder refused, or receipt unknown), "first_error_retained", and "duration_scope": "measured_in" is "handler" or "caller" only when the session declares it with the new start option "telemetry_duration_scopes" (--telemetry-duration-scope KIND=handler|caller), else "unknown"; "emitter" only reports whether the exemplars were emitted inside an OTP server (and which module) or a plain process, never what the duration measured. New operation trends/2 (observer trends, insider.live-trends/v1) lists each series' windows in fixed units (rate_per_min, p95_us, error_pct) with the first-to-last change and each window's exemplar losses; a declared handler series next to a declared caller series gets a conditional note, never a queueing conclusion. The digest adds "trends", "logger_bursts", and exemplar receipts and losses in its latency rows and text. New start options "logger_summaries" (--logger-summary RULE) and "logger_summary_interval_ms" count matching Logger messages per normalised message template, call site and level instead of recording each: one logger_summary event per burst per interval, its first message recorded as the exemplar ("exemplar_lost" when it was not); filtered.logger.summarized counts them. At most 64 bursts are told apart per interval; the rest fold into one overflow row per level ("overflow", "distinct_lost"). Lost exemplars and folded distinctions are read gaps telemetry_exemplar_lost, logger_exemplar_lost, and logger_summary_overflow. Strict disclosure withholds burst templates and call sites (their fingerprints are kept), the emitting module, and summary and exemplar durations without an allowed measurement, one drop record per value (exemplar durations at index:N).

    Security: a burst template is credential-masked before it is normalised, in every profile, and that masked template is what is grouped, fingerprinted, stored and exported (the mask is reported at attributes.summary.template). Normalising first could change a secret's shape, such as a high-entropy token's only digit becoming N, so that the export mask no longer recognised it and the template disclosed what the exemplar withheld. A token cut by the 160-byte template bound is dropped, and a masking failure yields a redaction marker.

  • Live one-shot inspections, after recon: Insider.Live.process/1 (observer process --name NAME | --pid PID) returns a process_info subset, the current stacktrace's top frames, link and monitor counts, binary count and bytes, and a mailbox summary by message shape and size class with the first shapes and the queued GenServer.calls whose callers exited, never a message value or sys:get_state (a shape shows an atom only as a tuple's tag, in every profile); bin_leak/1 collects every unprotected process and ranks what each still references (by_retained_bytes) and what was freed (by_freed_bytes); ports/1 counts ports by type and lists those of a --type or --owner with owner and OS pid, from one read of at most 50,000 ports, and in the rich profile each command line, masked structurally: split once at the first whitespace or control character, everything after the program is masked when the command names a credential anywhere or holds anything a shell may rewrite (an escape, a control character, $, a backtick), and the whole command when the program itself is in doubt; alloc/1 reports allocators through recon_alloc (component_unavailable without recon). Each is bounded (3 s deadline, heap guard, two at once; the exported result, masks and session status included, at most 64 KiB, its lists cut and counted in omitted), passes the disclosure profile and credential masking, and is recorded in a running session as an inspect.* event (new view source inspect) through the new Insider.Collector.Session.record_event/3. New errors process_not_found and protected_process; alloc/1 without recon returns the existing component_unavailable. Only alloc uses recon (BSD-3-Clause), when the node has it; the observer's --load pushes it. The welcome adds the operations, binary-leak and port-leak recipes, and a process step in the growing-mailbox recipe.

  • Poller port census port_top ("top_ports", observer --top-ports, default 5 with the poller): ports by type (the program's name, other when the program names a credential or holds an escape, a control character, $, or a backtick) with OS-process counts and each type's growth since the previous census, the owners holding the most, port_count_delta over the poll window, and Insider's own ports apart.

  • Live call traces. The new "calls" component (observer --component calls --calls MOD.FUN/ARITY, repeatable) traces calls to loaded functions, like recon_trace, but owned by the session rather than the caller: it is removed at stop, lease expiry, and amend, and the cleanup receipt's cleanup.call_trace shows traced_after 0, checked against the runtime's trace-session inventory. Each call is a call event and, with "calls_results" (exceptions by default, all, none), each failure a call.exception (severity error: call_id, duration_us, class, and the exception module such as ArithmeticError) and each return a call.return, paired with its call. In the rich profile the arguments, result, and reason are rendered with credentials masked and capped at "calls_max_bytes" (default 1,024); the strict profile collects none. "calls_max" (default 100) stops new calls while still recording running calls' results; more than "calls_rate_max" messages per "calls_rate_ms" stop the trace; each stop is a call.stopped event and later messages the calls_shed gap. It uses an isolated OTP 28+ trace session and never touches another tool's tracing; on OTP 27 it is refused with the new component_unavailable error. Unknown, unloaded, preloaded, or Insider functions are the new untraceable_function error. The digest gains calls (per function counts, durations, and failures with the arguments of the first), error signatures name the traced function, the compact format prints call events, and the welcome gains a "failing call" recipe. An amendment whose components leave "calls" out now drops its options. Ingress has a documented soft byte bound (development and test only): strict call messages carry only the arity; an inlet measures every trace message, charging a top-level sub-binary the binary it keeps alive, and stops the trace when more than 8 MiB wait for the collector (ingress_bytes); a 64 MiB heap limit is the last resort. The inlet's own mailbox and nested sub-binaries are not bounded; README "Call traces" gives measured worst cases. Flush and stop drain through the inlet, and what a stop could not drain, including a message the inlet held mid-admission, is the calls_undrained gap (calls_undrained_unknown when that count is only a lower bound). A call shed after "calls_max" keeps its place in pairing, and pairing that can no longer be exact stops the trace (pairing_limit, pairing_lost).

  • Live process and ETS evidence. With the "poller" component each poller interval (new "poller_interval_ms", default 5 s) records process_top: the top "top_processes" (default 5) processes by message_queue_len, by memory, and by reductions_delta since the previous scan (recon's proc_count and proc_window, with the poll interval as the window), each named by registered name, $initial_call, and current function; and ets_top: the top "top_ets_tables" (default 5) tables by memory and by size with their owner. "watch_processes" (observer --watch-process NAME, repeatable) records a process_watch sample of each named process every interval, following restarts; an unknown name is the new unknown_process_name error. Scans read only scalar process_info/2 items, the group leader, and the $initial_call dictionary key, never messages or ETS objects, and skip protected processes. Insider's own processes and tables are never ranked: they are summed under metrics.insider and copied into vm_sample as insider_process_count, insider_processes_bytes, insider_ets_tables, and insider_ets_bytes, so the Recorder's growing buffer no longer looks like an application ETS leak. Every poller event now carries wall_time. The welcome's growing mailbox recipe replaces its placeholder, and a memory growth recipe is new. The core Insider.Collector.Poller takes the scans and watches only when configured (top_processes, top_ets_tables, watch_names). Host protection takes precedence over Insider's own exemption, and an incomplete process footprint (scan limit, or a skipped host-protected process that is or may be Insider's) is reported unavailable in vm_sample, never as a total.

  • Live Telemetry discovery. Insider.Live.discover/1 (JSON twin and mix insider.live discover [--prefix a.b]) returns insider.live-telemetry-discovery/v1: the event names with an attached handler and the literal event lists in :telemetry.execute/2,3 and :telemetry.span/3 calls (spans expanded to start, stop, exception) of loaded application modules, each with its sources and module. It reads import tables and debug info only, never calls a debug-info backend or application code, skips files that no longer hold the loaded code, and is bounded (2 s deadline in a heap-guarded worker, 20,000 modules, 4,096 names, 2 MiB of debug info and 2,000,000 walked nodes per module in its own reader, 8 sources per name, 512 returned, two at once) with truncated_by naming every bound that dropped evidence (deadline, modules, names, too_large, walk, sources, events). Release layouts are scanned: only the OTP and Elixir applications' own ebin directories are skipped. A malformed "telemetry_events" is invalid_options before any scan. A "telemetry_events" entry ending in "*" (--telemetry-event 'shop.*') subscribes to every discovered name below the prefix, within the 64-event bound, and the start result lists the expansion under telemetry_event_prefixes. status/1 reports telemetry_subscriptions (each event's state, subscribed or detached, and seen), so an accepted name that was never emitted reads subscribed, seen 0. The welcome's unknown-event-names recipe now uses them. A recorded Telemetry event costs one more counter increment in the emitting process (its seen count).

  • Live digest and compact output. Insider.Live.digest/2 (JSON twin and the observer's digest --session S [--since N|latest-N] [--human]) summarises a window of the session in one call: insider.live-digest/v1 with counts by kind, severity, source, and supervisor offender, crash loops with their period and reason fingerprint, the top error signatures (kind, offender, exception module, normalised message head; HTML pages named, never quoted), latency tables from summaries and recorded durations, the longest mailboxes, VM deltas, and the window's filtered and gaps. The window is fixed when the digest starts (upto, the newest receipt then; later arrivals are left for the next digest), and one 3,000 ms budget (bounds.digest_budget_ms) covers the latest-N lookup and every read. --human prints a few plain-text lines for the developer; it calls a p95 near 5 s "consistent with GenServer.call timeouts" only when a disclosed failure carries that exit (call_timeouts, logged_call_timeouts). See the decision record 2026-10-22_live_digest_reads_a_fixed_window_…. The observer's events and watch take --format compact: one line per event (receipt, wall time, source, kind, severity, subject, key attributes; of a rendered conn only method, path, route and status) and a # line per batch with the cursors, disclosure profile, gaps, and filtered counts.

  • Bounded live reads. events_since/3 takes "upto", the newest receipt a read may return (from its starting cursor, after "latest" resolves, to the newest receipt; otherwise invalid_options with field "upto"). The read stops there and counts its receipt-range losses only up to it, from the receipts themselves, and is complete (truncated_by nil) when it reaches it. The digest reads its window this way, so its losses are exact whatever order the Recorder evicts in: a later eviction is no longer counted in the window and a withheld receipt in it is no longer hidden.

  • Live time and units. Telemetry events carry wall_time, read in the emitting process (a summary's is when it was recorded), and Poller samples the time they were taken. Every Telemetry time measurement a read discloses as an integer is repeated in microseconds under attributes.durations_us. The full welcome reference gains time, which says what wall_time and monotonic_time mean per source and the unit of every duration.

  • Several agents can share a live session. Reads and subscriptions take "reader" (observer --reader NAME), and status/1 lists named readers with their cursor, lag, last read, and subscription. stop/2 refuses with readers_active while another named reader is active, unless "force" (--force). A stopped session stays readable for 120 s, so peers can drain it. amend/2 (mix insider.live amend) changes a running session's components, events, measurements, filters, and poller options without losing its history, cursors, readers, or subscribers, and readers see a live.session_amended event; a "telemetry_events" prefix such as shop.* is expanded as at start and listed under telemetry_event_prefixes. An option given as nil (observer --reset FLAG) returns to its default, and kept poller options return to theirs when the amended components leave the poller out (a components reset included). handoff_record/1 (mix insider.live handoff) returns what another agent needs to continue the session, its poller configuration included. Every configuration says that recording options apply to every reader, while views are per reader ("scope"). The welcome adds a tandem section and the "missing values" and "several agents" recipes. New error codes: readers_active and amend_failed.

  • The Lab escript (mix escript.build, then ./insider-lab live …) is the documented observer for concurrent agents, because it never waits on Mix's build lock. Observer documents report installation.insider_commit, so an agent can tell when to rebuild a stale escript.

  • mix insider.live reports submit --dry-run always previews, overriding --confirm and every host opt-in. The result's authorization names the effective opt-in and what was overridden, and a real submission writes it to standard error before its first gh call. reports and reports submit select by --fingerprint (repeatable) or --session; report --session cites a session, and otherwise a report cites the session of the last target command (new report context key session; older records are read with it as nil). reports groups the shared queue by node and session, from each report's occurrences, so the same report filed in two sessions stays selectable by each. --session accepts an ASCII identifier and refuses anything else as invalid_options.

  • The welcome (quick start and full) states effective_disclosure: the node's current profile, its source, and what it lets leave the node.

  • Frontend traces in a live session. The Lab's mix insider.live otlp-receive --session ID is a loopback-only OTLP/HTTP trace receiver (protobuf or JSON, gzip, at most 4 MiB, default 127.0.0.1:4318, --port, --bind, --for) that forwards each span to the new Insider.Live.ingest_spans/2 (and JSON twin), which records it as an otel.span event under the session's span contract, disclosure profile, and credential masking, with service from the exporter's resource. It prints one NDJSON line per export with its counts and trace ids, renews the lease, and stops on SIGTERM, --for, or the end of the session. New observer codes non_loopback_bind and port_unavailable; welcome recipe "follow a frontend action". Ingest runs in the live owner, ordered with start and stop, so spans never reach a later session; export lines carry only counts and trace ids; the receiver accepts the next connection only after its previous report was written. A timeout from ingest_spans means the outcome is unknown; ingest is idempotent per {trace_id, span_id} while the id is among the session's last 16,384 ingested ids (duplicate and seen_evicted counted), the receiver retries a timed-out chunk once and then answers 503 target_timeout, a busy ingest (the owner's admission full) is answered 503 target_busy and the receiver keeps receiving, every amendment (even one rolled back) resets dedupe without counting it as seen_evicted, and a busy or timed-out lease renewal is retried once after a jittered backoff, the delay capped to leave 250 ms before the lease's estimated end. Decision records 2026-10-22_otlp_ingress_is_a_loopback_lab_receiver_that_only_the_target_masks, 2026-10-22_otlp_ingest_timeout_is_outcome_unknown_with_bounded_dedupe, and 2026-10-22_otlp_receiver_renewal_retry_is_capped_by_the_lease.

  • Live OpenTelemetry spans and traces. The new "otel" component records every span the node's OpenTelemetry SDK ends as an otel.span event, by tracing the SDK's span end in an isolated trace session (OTP 28+; on OTP 27 start/1 returns component_unavailable with reason requires_otp_28), without adding or changing any processor, exporter, tracer, or sampler; traces_exporter: :none still exports nothing. Throttled rather than admission-controlled (trace messages cannot be refused by their receiver): a valve pauses the trace above 1,024 waiting spans; every read overlapping a pause reports otel_paused, or otel_paused_ongoing while it lasts, with an unknown count, and spans received above that are shed before being built. The bound is soft and the component is for development and test only. Also otel_shed/otel_invalid gaps, origin and "otel_min_duration_ms" filters counted under filtered.otel, rich-only span attributes and status messages, and clean removal on stop. Insider.Collector.Otel.ingest/1 records span maps from outside the node. Insider.Live.trace/3 returns one trace's span tree merged in time order with the Logger and Telemetry events of the same trace (or of a span's process inside its window), and Insider.Live.timeline/2 one process's or request's events across every source; both report what they could not join and are bounded (JSON twins and observer trace/timeline commands). Logger and Telemetry events take the SDK's otel_trace_id/otel_span_id as causality, Logger subjects name their node, and Telemetry events carry their emission wall time. New error code component_unavailable. The oban origin now covers oban_pro, oban_met, and oban_web processes. Welcome: trace and timeline operations, the 5xx recipe reads the failing request's trace, and a new slow-request recipe. A stop or amendment seals the otel capture with the other ingress components before its last copy, and the otel losses (otel_invalid, otel_shed, pauses) carry through amendments and the drain window; a pause ongoing at a seal ends with that capture, and the paused state is never summed across segments, so a later segment's pause is otel_paused_ongoing on every read while it lasts; amend takes --otel-min-duration-ms and --reset otel-min-duration-ms.

  • Live welcome agent quick start. Insider.Live.welcome/1 (and the observer's welcome) now returns insider.live-welcome-quick-start/v1 by default, about twenty lines: numbered steps, the five core observer commands with real flags, the first-contact --load command, "measurements are opt-in" (in the strict profile; rich returns every measurement unless some are selected), and how to stop, plus symptom recipes (latency, crash loop, 5xx, and placeholders for a growing mailbox and unknown event names). welcome(%{"full" => true}) and mix insider.live welcome --full return the full reference, now insider.live-welcome/v2 because the default no longer returns it; it also lists every observer flag's value syntax (such as module:NAME) and the observer's error codes with their exit statuses. capabilities/0 reports quiet_default_telemetry_events.

  • mix insider.live --help, help OPERATION, and OPERATION --help print usage text with each flag's value syntax and examples and exit 0, without a target.

  • Live reading scales to sparse views and late joiners. events_since/3 accepts cursor "latest" (the observer's --cursor latest), an empty batch at the newest receipt from which to tail, and a "scan_limit" read option (1 to 1,000, default 1,000; --scan-limit) that bounds the retained events a read examines. Every batch reports "truncated_by" (limit, max_bytes, scan_limit, deadline, or nil). status/1 reports "next_receipt" and the Recorder's fill ("recorder": oldest_receipt, retained_events, retained_bytes, max_events, max_bytes), and invalid_cursor names oldest_receipt and next_receipt. subscribe/3 takes "cursor" (an integer or "latest") and "max_events", a total event budget the owner enforces. The observer's watch gains --from-cursor N|latest, --for DURATION, and --max-events; its stopped line reports events and the next_cursor to resume from.

  • Live sessions are quiet by default and filter in the node before recording. Without options a session records Logger events at warning or more severe, OTP crash, supervisor, and SASL reports, each Ecto repository's queries over 100 ms (discovered from :ecto_repos), every Phoenix request, and every error, and nothing Oban's own machinery emits. Record-time filters (logger_level, logger_include, logger_exclude, exclude_origins, telemetry_min_duration_ms, telemetry_event_min_duration_ms) run in the emitting process through a gate kept in :persistent_term; a dropped event costs one decision and one counter increment. telemetry_summaries folds a high-volume event into one summary event per interval with count, errors, and latency p50/p95/max. events_since/3 and the new subscribe/3 take a per-reader "view" over the same recorded stream, and every batch reports "filtered" counts per filter, record-time since the cursor and read-time for the view, so silence is never ambiguous. The observer gains --logger-level, --logger-include, --logger-exclude, --exclude-origin, --telemetry-min-duration-ms, --telemetry-event-min-duration, --telemetry-summary, --telemetry-summary-interval-ms, and --view-* flags.

  • Live record-time gates have a supervised cleanup owner, Insider.Live.Gates, started before the live owner. It erases a gate when its session ends, its owner dies, or its start is interrupted, and holds at most 8 (start/1 then returns busy). Gate creation is bounded to 500 ms: start/1 returns timeout when the keeper is late (the creation is aborted) and unavailable when it is down; the start reserve is 3,500 ms (including 200 ms for the disclosure profile's Ecto redact-field collection). Summary tables pass to the live owner if the keeper dies, so summaries survive a keeper restart; a summary sample that cannot be stored is reported as the gap telemetry_summary_lost, never as summarized. In the strict profile a summary's duration statistics follow the host measurement allowlist (rich summaries carry them unchecked), a sample's fields always land in one interval, and a stopped or expired session's terminal batch carries its pending summary.

  • Live disclosure profiles, chosen by the host with config :insider, :live_disclosure: rich (the default in development and test) returns Logger message text and metadata, Telemetry metadata such as a repo query's source and query, and all measurements, rendered by Insider.Collector.Rich within fixed size, width, depth, node, and time bounds and without calling application code (no report_cb, no struct Inspect implementations); strict (the default in ci; environments where live observation is denied report only strict) is the previous boundary. start/1 accepts "disclosure" to narrow a session, and a richer request is the new disclosure_denied error. capabilities/0 reports disclosure_profile, disclosure_profile_source, disclosure_profiles, and masking_policy_id; session start and status report the effective profile and the masking policy id. The Lab observer's start accepts --disclosure. The Logger and Telemetry collectors accept rich: true.

  • Insider.Redaction.Credentials (insider-credential-masking/v1) masks values under credential-named keys and secret-shaped strings (HTTP Bearer and Basic credentials, JWTs, PEM blocks, provider key formats such as sk_live_…, URL passwords, credential assignments, and high-entropy tokens) at every nesting level of every live event in every profile, and leaves a mask redaction record with its reason for each.

  • Live observation of a running node, with or without Phoenix: Insider.Live (capabilities/0, start/1, events_since/3, renew/1, status/1, stop/1, subscribe/2, unsubscribe/2) and Insider.Live.JSON, which returns each result as one canonical JSON document for Tidewave project_eval. Arguments and results are plain, distribution-safe terms for a later Erlang-distribution observer node. A supervised, named Insider.Live.Owner, started under Insider.Supervisor only when the node resolves to development, test, or ci from config :insider, :environment or its Mix environment, owns the one collector session, so the caller can exit. A renewable lease (default 2 minutes) stops an abandoned session through the normal cleanup path and leaves a receipt that status/1 reports. Reads return redacted events after a recorder cursor, without a freeze, with exact eviction and withheld counts and counter-delta gaps for admission and ingress losses under a closed reason vocabulary; errors use a closed code vocabulary. Subscribers are monitored, bounded, and receive a terminal batch with the receipt. In the strict disclosure profile, Logger message content, report fields, and metadata are never collected, and every event crosses a fixed live disclosure boundary: only W3C-shaped trace_id and span_id causality survive, binary supervisor ids are digested, and Telemetry measurements are numeric values from a host allowlist (config :insider, :live_telemetry_measurements). Calls take one of 16 owner admission slots (busy otherwise) and carry an absolute deadline; a request handled too late is refused before any side effect. The environment is checked on every observation: if it stops being allowed, the active session is stopped as revoked, retried on a timer if cleanup fails, and observation returns environment_denied.

  • Lab observer node: mix insider.live and insider-lab live drive Insider.Live in another local BEAM node over Erlang distribution (capabilities, start, events, status, renew, stop, and a long-running NDJSON watch that renews the lease, unsubscribes on SIGTERM, and ends on target loss). Each command starts a hidden, non-listening observer node, refuses non-loopback hosts, reads the cookie only from an owner-only file, calls with :erpc under explicit timeouts, and prints canonical JSON with a closed error vocabulary on the existing Lab exit statuses. A target without Insider or with a different version is refused; --load pushes the observer's Insider (and missing jason/telemetry) with :code.load_binary/3 and starts it, only on development, test, or ci targets.

  • Live welcome document: Insider.Live.welcome/0 and Insider.Live.JSON.welcome/0 return insider.live-welcome/v1, generated from the code's own tables: every operation with its options, defaults, and bounds, the error codes, components, allowed measurement names, report categories, the disclosure profile, the observer and Tidewave transports with example invocations, the Insider version and compiled Git commit, a short agent guide (first steps, the act-then-read loop, stopping, and the duty to report), and the node's runtime facts. hash is the SHA-256 of everything except hash and runtime; capabilities/0 carries it under welcome. Drift-guard tests compare the document with the exported functions, option behaviour, the error codes the source can return, and the observer's command table. mix insider.live welcome prints it, and the first observer command against a target carries it under "welcome" (later ones a pointer).

  • Agent reports about Insider itself: Insider.Live.report/1, Insider.Live.reports/0, their JSON twins, and mix insider.live report --category C --message M, with the closed categories bug, doc_mismatch, missing_capability, and confusing_output, a 2,048-byte message, and automatic context (version, commit, welcome hash, node, environment, last operation and error code; never payloads or option values). The node keeps a bounded, deduplicated in-memory queue (Insider.Live.Reports, started only where live observation is allowed, with the owner's admission slots and deadlines); the observer keeps the same rule in a JSONL queue under INSIDER_LIVE_REPORTS_DIR, validating every row on read and keeping the submission ledger to queued fingerprints. mix insider.live reports lists it, copying a target's queue with --node, and reports submit files GitHub issues on hiivemarkets/insider through gh, deduplicated by fingerprint, only with --confirm or config :insider, :live_report_submission, :github (a target's setting covers only that target's own reports); otherwise it prints what it would send. New observer error codes: report_queue_unavailable and report_submit_failed.

  • usage-rules.md and guides/agents/live-observation.md, listed with guides/ in the mix.exs package files so mix usage_rules.sync finds them, and a host AGENTS.md snippet in the README.

  • Insider.Recorder.read_since/3, a cursor read of retained entries in receipt order that needs no freeze trigger, takes no admission lock, and reports the exact eviction count for the read range.

  • Insider.Collector.Session.read_events/3, which drains the visible ingress inboxes and returns events redacted under the session's trusted classification policy, with Recorder and ingress loss counters.

  • A Lab-only fault-and-rerun oracle for background workers, tools/insider_lab/priv/probes/fault_rerun.exs (InsiderLab.FaultRerunOracle.run/1), for agent-written probe tests. It stubs every exported arity of up to 16 declared provider functions through a caller-supplied installer, runs the worker once with no fault as a healthy control, then against a fresh fixture with a fault declared at one provider call (a returned error, a raise, or a lost response) and again as the retry, up to 8 attempts. It compares the distinct effect identities of each run with the provider ids a caller projection of committed rows returns, grouped by the boundary that creates them, so equal ids from two providers never match. The control must succeed, reach the fault position, and make exactly the expected, referenced effects, or the call is infrastructure_failure. Fault runs are confirmed (orphaned_effect, repeated_effect, missing_effect), not_reproduced (converged_once), or not_observed (fault_not_reached, effect_outside_attempt for a declared effect made after perform returned or outside the attempts, retry_did_not_succeed, an adapter failure, or an incomparable value). A declared arity list that does not match the exported arities is refused before any adapter runs. A boundary with an idempotency key replays the first response for a repeated key: a concurrent caller waits up to 2 s for the first caller's response, and responses are cached for at most 512 keys within a 1 MiB, 65,536-term budget and 8 MiB per scenario. A key that cannot be compared or replayed (including a responder re-entering its own key) is key_not_comparable, never a confirmed repeat. It prints one insider.fault-rerun-oracle/v1 line per call with call counts per arity, result tags, exception modules, and per-call labels of HMAC-keyed effect and key fingerprints, never an argument, response, id, key, or reference value; at most 512 calls are recorded per scenario. See decisions/2026-10-21_fault_rerun_oracle_owns_the_provider_recorder.md.

  • A Lab-only actor differential access-control oracle, tools/insider_lab/priv/probes/actor_differential.exs (InsiderLab.ActorDifferentialOracle.run/1), for agent-written probe tests. It runs one host operation as up to 16 declared actors, each against a fixture rebuilt by a caller-supplied function, and compares each outcome and an optional id-free state projection with the declared rule. Entitled controls must be granted and change the declared effect keys, and refusal controls must be refused without changing state; an unhealthy control or a malformed declaration is infrastructure_failure with no verdict. Compared actors are confirmed (wrongly_granted, state_changed_while_refused, wrongly_refused, granted_without_effect), not_reproduced, or not_observed (including a starting state that differs from the control's or cannot be compared). It prints one insider.actor-differential-oracle/v1 line per call holding field paths and kinds, GraphQL type names, error codes, and per-call HMAC equality, never a response or state value. A value is fingerprinted only after a walk of at most 65,536 terms bounds its serialized size to 1 MiB, and an unfingerprinted value never compares equal. See decisions/2026-10-21_actor_differential_oracle_is_a_probe_library.md.

  • mix insider.oracle, a Lab-only runner for the three fixed ExUnit oracles that never edits the target checkout. It starts mix test with MIX_EXS naming a fixed bootstrap that compiles the target's mix.exs, bypasses a declared host test alias, and prepends a run-local overlay to :test_paths, whose helper requires the host helpers and then the oracle; no host run alias is involved. An explicit insider.oracle-host-profile/v1 file declares the mix command, alias handling, passthrough variable names, and database suffix; every other variable is removed from the child. The run directory must resolve, after symlinks, outside the target and its Git work tree. Each run writes a versioned insider.oracle-run/v1 record (oracle id and SHA-256, inputs, exact command, target revision, fingerprint budget, and before/after content fingerprints with changed paths, profile fingerprint, timestamps, exit status, output policy, oracle report, cleanup verdict, completeness state, and outcome), output filtered by a fail-closed policy (allowlisted summaries by default, or exact-value redacted), and copies of the files that ran. Target fingerprinting has time, listing, file-count, and content-byte budgets, and a target containing a Git submodule or nested repository is refused (target_has_nested_repository), since Git lists none of its files, and any path the fingerprint cannot read (including Git's stderr-only "could not open directory" warnings) is refused or fails the run as target_path_unreadable. Runner-assigned variables (MIX_EXS, MIX_ENV, INSIDER_ORACLE_*) cannot be passed through and always win; redaction runs on raw bytes, so multiline values are removed whole; and the live run and the decoder reject reports of the wrong shape or for a different application, key list, or event than requested, and records whose verdict contradicts their evidence. Non-complete states (empty_selection, unsupported_source, truncated, infrastructure_failure) exit 3, 4, 5, and 70; a missing result line is always infrastructure_failure. See decisions/2026-10-21_oracle_runner_uses_a_test_path_overlay_and_saves_versioned_runs.md.

  • Generated documentation with ex_doc (mix docs, a dev-only dependency; the production dependency graph and artifact gate are unchanged). New guides/people/ pages (overview, how a session works, safety model, what exists today, try it locally) and guides/agents/ operating contracts (mix insider.candidates, the three oracle artifacts, mix insider and the protocol envelope, the Sentinel chain, mix insider.privacy_corpus, the load harness and scripts/verify-load-evidence, refusals, reading a report). Lab gains the same dev-only dependency so (cd tools/insider_lab && mix docs) renders its API reference. README corrections made while grounding the guides: the Sentinel paragraph no longer lists checkout, dependency restoration, source changes, or draft PR creation as implemented; bisection's unavailable-executor outcome is inconclusive/executor_state_unknown rather than operation_failed; mix insider input errors (insider.mix-task.error/v1, exit 64) and its fixed diagnostic budget, CLI JSON depth/width limits and protocol budget defaults, the privacy corpus task's staging/production-only environment and 16 MiB file bound, the --max-candidates/--max-duration-ms switches, per-defmodule alias scoping, control-byte oracle-hint omission, the 4,095-byte INSIDER_ORACLE_KEYS bound, invalid-context null echo, the tick-or-segment lag definition, and LICENSES/ in the layout table. The Lab README table now lists INSIDER_ORACLE_KEYS and INSIDER_ORACLE_CONTEXT and names Bisection in the Phase 6 chain; the Load README verifier output list includes directory.

  • A third fixed Lab-only value-free ExUnit oracle, tools/insider_lab/priv/oracles/otel_global_state_test.exs (insider.otel-global-state-oracle/v1), that fingerprints the OpenTelemetry default tracer and text-map injector/extractor globals before the suite and after it, reports changed, unchanged, inconclusive, or operational_failure (opentelemetry_api_not_loaded, invalid_context), records whether the opentelemetry SDK application was loaded and started, echoes INSIDER_ORACLE_CONTEXT, and never emits tracer or propagator module names or configuration. The Lab gains opentelemetry_api as a :test-only dependency for the artifact's tests; the root application is unchanged.

  • A live Lab integration test that runs the documented Phase 6 offline repair chain end to end on a real sandbox executor—three fresh confirmations, regression, coding-agent handoff, candidate submission, verification, repair report, draft proposal, source-ownership routing, dedup ledger, and the draft-creation executor with its test provider—and proves that one candidate identity threads through every artifact. README status now records which Phase 6 artifacts exist and what remains before any provider authority.

  • A read-only Insider.Policy.ProtectedTargets.audit_matrix/1 export and the committed, test-pinned docs/protected-target-audit-matrix.json (insider.protected-target-audit-matrix/v1) that enumerate, per supported OTP major, every fixed registration name and control-target class with the denial decision the policy produces. The matrix is derived from policy data without runtime inspection and contains no PIDs or timestamps; application targets and an exception-review owner remain undeclared.

  • Load reports localize missed scheduled operations: each phase summary gains a scheduling section with per-segment (warmup, steady, overload, recovery) and per-cause (skipped_tick, segment_end_remainder) counts plus max_tick_lag_us, and a report whose sums do not reconcile with missed_operations is invalid. A phase that fails before its workload completes reports its unexecuted steady and overload work as segment_end_remainder misses so the failed report remains valid and keeps its original failure reason. scripts/verify-load-evidence recomputes the digests and identities of emitted evidence directories offline and prints one JSON verdict line per directory. Pass/fail gates and profiles are unchanged.

  • A Lab-only Insider.Sentinel.Bisection that binary-searches a host-declared ordered list of two to sixty-four disposable sandbox targets for one adjacent nonreproduced/reproduced pair bracketing a confirmed regression, with two fresh confirmations per probed index, proven endpoints before any midpoint, nondeterministic, inconclusive, and unclean-executor stops, bounded probe and duration budgets, and a canonical insider.bisection-record/v1 whose fixed controls record no repository read, checkout, source mutation, Git authority, or network effect, and whose fixed limitations record that outcome monotonicity is a host assumption and that indices off the search path are never probed. Standalone validation replays the search path; validate_with_evidence/6 rederives every index decision from the referenced confirmation records. Completion reports the adjacent boundary pair with proof=adjacent_boundary_isolated, never an earliest reproducing target or a cause.

  • A Lab-only privacy corpus runner (Insider.Lab.PrivacyCorpus, mix insider.privacy_corpus) that projects caller-supplied synthetic Logger and Telemetry items through the exact ingress handler code paths for a selected ingress profile and emits a canonical insider.privacy-corpus-report/v1 with retained field names, bounded suppression counts, item kinds, and canary-token coordinates, never the values of retained fields. It is bounded, fails closed on unknown shapes and unused tokens, creates no atoms from corpus input, and ships a fake-valued schema example. The application corpus and the review of every retained field remain human work; a clean report grants no staging or production authority.

  • A Lab-only, agent-requested ExUnit candidate inventory with executable-AST signal detection, adopter case-template support, identity-matched cleanup ranking, non-following bounded traversal, source/configuration fingerprints, explicit scan/truncation accounting, and a JSON-first mix insider.candidates interface. Literal application-env and Telemetry targets are emitted without configured values; unqualified callees are marked syntactic, and simple visible aliases produce declaration-ordered syntactic identities without code loading or expansion. Ambiguous and dynamic targets stay unresolved. It performs no background scanning or test execution and labels every result as a candidate rather than a confirmed defect.

  • Candidate inventory telemetry_event targets (scanner revision ast-v8-telemetry-event-targets): one resolved entry per literal event path passed to :telemetry.attach/4, :telemetry.attach_many/4, or :telemetry_test.attach_event_handlers/2, with dynamic lists or elements left unresolved. :telemetry_test.attach_event_handlers/2 is ranked as a VM-global handler attachment without cleanup credit because its handler id is the returned reference. Every target now carries a static oracle hint naming the fixed Lab artifact schema and environment inputs that match the identity (null for handler ids, unresolved targets, and identities the artifact would reject); the hint installs and authorizes nothing.

  • A fixed Lab-only ExUnit application-env oracle artifact that reports bounded, value-free before/after evidence for one agent-selected target without spawning tests, interning target names, or exporting its per-run HMAC key.

  • A fixed Lab-only ExUnit Telemetry dead-handler oracle that reports bounded before/after counts for one agent-selected event without emitting handler identities, destination PIDs, functions, configuration, or event payloads.

  • The application-env oracle accepts INSIDER_ORACLE_KEYS, a bounded comma-separated set of 1 to 16 distinct keys in one application, as an alternative to the single INSIDER_ORACLE_KEY; exactly one selector must be set. Multi-key reports keep the v1 schema, add a per-key targets list, and derive an aggregate status; the single-key shape is unchanged apart from additive fields.

  • Both oracle artifacts echo an optional opaque INSIDER_ORACLE_CONTEXT (up to 1,024 printable UTF-8 bytes without control characters) verbatim as context, report null when it is unset, fail closed with invalid_context otherwise, and declare context_is_caller_supplied_and_unverified as a limitation in every report, including operational failures. The artifacts never interpret the context.

  • A separate non-published synthetic load/soak harness with fixed profiles, revision- and runtime-bound canonical evidence, structural failure gates, and CI retention across the supported Elixir/OTP matrix without claiming an approved production budget or enabling production observation.

  • Bounded, canonical observability trigger and export contracts. External signals remain inert requests without collection authority, while outbound summaries are re-derived from validated redacted capsules and carry no raw events, artifacts, endpoints, credentials, callbacks, or delivery claims.

  • Deterministic Sentry ingestion-event and Datadog Events v2 mock mappings in a capsule-bound canonical envelope that always reports mock: true and delivery_status: not_attempted, plus a contract-only host handoff behaviour. No provider client, transport, delivery lifecycle, or rollout support is included.

  • A revision-aware production-readiness dossier, evidence index, planning-only staged-canary runbook, and canonical non-authoritative input worksheet. They retain missing evidence and human approval as blockers and grant no staging or production authority.

  • A Lab-only, disabled-by-default draft-creation gate that recomputes exact verified evidence, requires destination-specific disclosure approval, and emits bounded canonical receipts through host-allowlisted, provider-idempotent draft-only integrations without exposing credentials, merge, or deployment.

  • A Lab-only canonical coding-agent boundary. A self-contained handoff is emitted only from an exact ready capsule/manifest/regression graph plus two fresh matching failed confirmations; a returned repair reuses the bounded verification-candidate schema and remains inert, disclosure-unattested, and explicitly unverified until the existing isolated verifier reruns it.

  • A host-owned supervised Collector Session that composes the permitted Logger, Telemetry, Poller, and Recorder collectors under one immutable protected-target binding. It denies staging/production before side effects, permits one globally owned active session, provides bounded health and cleanup evidence, retains at most 32 terminal receipts, and isolates its one_for_all session root from unrelated application children.

  • A host-owned immutable protected-target policy for Runtime and Poller, with structured pre-probe denials for fixed OTP registrations, the bound Insider control plane, and additive host declarations. Explicit ingress profiles now mechanically disable Logger payload/message semantics and require Telemetry allowlists for denied staging/production readiness profiles.

  • A physical production-artifact boundary: root :insider now ships only the collector/evidence core, while Sentinel, fixtures, contract/invariant and scenario execution, CLI/Mix/escript surfaces, and the restart-capture fixture harness live in the non-published dependent tools/insider_lab project. A fail-closed fresh source, beam, application, release, and isolated-VM inventory gate verifies that Lab capabilities are absent from production artifacts.

  • A canonical offline draft-proposal artifact that accepts only recomputed, verified five-run repair evidence and grants no network or repository authority; publication remains blocked pending disclosure attestation.

  • A Lab-only canonical source-ownership companion bound to an exact draft-proposal v1, its bounded simple unified-diff candidate, and direct provider-neutral declaration bytes. It emits only opaque, declared-unverified routing labels, uses last-match-wins semantics, leaves unmatched paths unassigned, and grants no identity, assignment, authorization, repository, network, provider, or mutation authority.

  • A Lab-only bounded offline incident/proposal deduplication ledger. Canonical capsules may enter before proposal eligibility; proposals bind to a retained exact capsule only after full evidence-graph recomputation. Exact artifact repeats are idempotent, new content in a hashed finding group is retained as new evidence, capacity refuses visibly without eviction, retained bytes are physically detached, bounded, and self-revalidated, and canonical receipts retain only content-addressed references, a bounded numeric admission total, and bounded counts.

  • A production observation threat model, fail-closed readiness matrix, and separate revision-bound human gates for a bounded staging canary and a later production release.

  • An Insider.Runtime facade and mix insider task for bounded, scalar-only same-node process inspection with machine-readable capabilities and results.

  • A run-correlated Sentinel lifecycle signal when an external exit status is observed, without claiming Port-down or process-group state.

  • Initial Mix application and supervision-tree scaffold.

  • Agent engineering guardrails, local Git hooks, and CI quality matrix.

  • Versioned, bounded request and effect-honest result protocol with typed failures and hostile-input-safe decoding.

  • Deny-by-default capability and environment policy with trusted runtime context, effective limits, safe discovery, and bounded audit evidence.

  • Deterministic faulty and healthy fixture pairs backed by real OTP process, supervision, mailbox, monitor, timeout, and Telemetry signals.

  • A bounded, atom-safe event v1 vocabulary with canonical JSON, extensible string kinds, explicit stream ordering, and conflict-aware causality.

  • Explicit same-node logical identity declarations with bounded generation tracking, monitor cleanup, and conflict-safe event attachment.

  • A bounded priority flight recorder with direct non-mailbox admission, visible loss accounting, rate shedding, and one-shot causal-window snapshots.

  • A structured OTP Logger collector with pre-translation capture, a fixed-slot handoff inbox, bounded term shaping, and explicit overload health counters.

  • A bounded restart-recurrence detector using explicit OTP supervisor semantics, trusted receipt time, distinct child incarnations, and deduplicated findings.

  • A fail-closed redaction boundary with fingerprinted pure-data policies, bounded hostile-term traversal, and deterministic Event-compatible manifests.

  • Bounded portable provenance with independently addressable code, configuration, dependency, runtime, and target evidence plus explicit unavailable and policy-redacted states.

  • Offline-validating incident capsules with enforced root-aware redaction, content and event-chain integrity, and digest-only large-artifact references.

  • Failure-isolated VM and explicit-process polling with scalar-only evidence, hard target/deadline bounds, and visible timeout and truncation accounting.

  • A bounded mailbox-growth detector requiring sustained queue growth without observed reductions, with evidence-gap resets and declared buffer exclusions.

  • Versioned application semantic contracts with deterministic discovery, explicit sensitivity and ownership, and bounded failure-isolated callbacks.

  • A detector-neutral finding envelope with exact restart and mailbox schemas, evidence correlation, and byte-preserving legacy restart capsule support.

  • Semantic invariant evaluation with machine-readable callback outcomes, policy-aware evidence, confirmed recorder-backed findings, and offline capsule round trips.

  • A canonical collector-to-Sentinel manifest that binds exact capsule bytes, preserves prerequisite availability and redaction, and fixes a non-authoritative disposable confirmation posture.

  • Canonical portable reproduction scenarios with bounded semantic steps, deterministic seeds, expected finding fingerprints, and cleanup-reserved disposable execution.

  • A provider-driven disposable-target lifecycle with exact observed provenance, owner-scoped leases, synchronous cancellation, inventory-backed cleanup evidence, and quarantine for unproven reclamation.

  • An optional trusted sandbox body-owner seam that runs bounded allowlisted work on the live owner lease between exact provenance observation and provider cleanup, with receipt-and-termination gating, declared stop-phase bounds for TERM-to-KILL escalation, and quarantine when stopping cannot be proved.

  • Clean-target confirmation records that jointly bind manifest, capsule, scenario, requested and observed target, lease owner, observer run, repair oracle, complete evidence, and inventory-backed cleanup before confirming an exact incident fingerprint.

  • Canonical data-only regression recipes that embed an eligible source confirmation and exact scenario, plus a bounded two-fresh-run classifier that reports consistent failing-before evidence without treating source replay or repair evidence as proof.

  • A bounded whole-step scenario minimizer that requires two fresh baseline confirmations and three fresh isolated confirmations per candidate, stops on nondeterminism or cleanup uncertainty, returns best-known evidence on exhaustion, and emits a canonical one-step-minimality record with an explicit execution-search duration scope without claiming global minimality.

  • A bounded verification orchestrator that proves two fresh failing-before confirmations before dispatch, executes two independent host-allowlisted post-repair sandbox runs, and emits a canonical verdict bound to opaque candidate bytes, exact oracle receipts, provenance, gates, and zero-resource cleanup.

  • A private bounded external-process seam with host-fixed profiles, canonical same-owner machine receipts, raw-output non-retention, direct process cleanup, and backward-compatible confirmation and verification receipt v2 bindings.

  • A bounded, content-addressed repair-report manifest derived from exact capsule, Sentinel handoff, and verification evidence, plus deterministic Markdown that exposes the causal invariant, declarative reproducer, five-run proof, candidate diff, provenance changes, redaction boundary, verification matrix, coherent cleanup and executor counts, and known uncertainty without accepting caller- authored success claims.

  • Bounded partial protocol result values on every non-success status, including unsupported operations, allowing a sandbox to retain a valid body receipt when timeout, cancellation, body failure, or cleanup controls operational status without converting evidence into success.

  • Recorder-owned sensitivity companions bound to exact event bytes and redaction policy fingerprints, with automatic fail-closed capsule export and separate bounded storage accounting.

  • A bounded Telemetry allowlist collector with optional exact-width OpenTelemetry correlation, fixed-slot ingress, lifecycle-gap health, safe handler-failure evidence, and ownership-aware cleanup.

  • Process-subject attribution for synchronous Telemetry emitters and an opt-in Logger payload-omission boundary for privacy-sensitive causal capture.

  • An opt-in bounded ERTS system-event collector using isolated OTP 28-29 trace sessions and an explicit conflict-refusing OTP 27 compatibility mode, with trusted runtime-context gating, closed local-identity projections, mailbox-overload self-disable, and receiver-termination cleanup evidence.

  • A transport-only CLI with direct term, canonical JSON, and recoverable NDJSON framing, machine-readable operation availability, bounded isolated dispatch, hostile-input-safe decoding, and deterministic protocol-aware exit statuses.

  • An executable, test-compiled Phase A harness that honestly advertises and runs one real faulty or healthy fixture through trusted policy and bounded portable results, with supervised cleanup independent of CLI caller timeout.

  • A reusable restart-capture seam that causally fans trusted normalized events through the recorder and recurrence detector into one offline-valid redacted capsule, plus a test-only dual-authorized, intent-idempotent fixture host proving faulty/healthy, overload, started timeout, cancellation, export-failure, caller-death cleanup, recorder-crash isolation, fixed-cache conflict/capacity behavior, and cleanup outcomes. The real restart fixture now owns its Agent, supervisor, and workers below a caller-monitoring process, enabling lease-token cancellation and host-death cleanup without a synthetic lifecycle fixture. Its resource notifications are opt-in, preserving ordinary fixture mailbox isolation. The shipped capture owner now also exposes a correlated reserve/publish/acknowledge admission before recorder work, plus a phase-checked begin/execute/cancel lifecycle. Duplicate lifecycle messages are idempotent, and one retained inventory drives cleanup and accounting. The acceptance host distinguishes published resource PIDs from reserved but unmaterialized slots and accounts for all ten unique fixture and capture resources and the full admission-to-cleanup duration, including cancellation after capture admission.

Changed

  • The production-readiness evidence index is now insider.production-readiness-evidence-index/v2. Each evidence set and the assessed revision name a revision label of the pre-release snapshot in place of git_revision and tree_sha, because that history is not in this repository. Report identities and file hashes are unchanged.

  • Documentation layout: the README is now a short synopsis (what Insider is, a quick start, when to use it and when not, Insider and Tidewave, status and safety). Its reference sections moved, with their examples, into topic files under docs/, and docs/README.md indexes them with a task table that names the file, the section anchor, and its approximate size. Stale claims found during the move were corrected (lease-renewing calls, observer flags, the welcome quick start's ten steps, built-in duration minimums, view sources, session collectors, Digest authorization masking, status and roadmap). AGENTS.md links the index and states what belongs in the README versus docs/. usage-rules.md, the guides, the Lab README, moduledocs, and the documentation tests point at the new files. mix docs renders docs/ in groups that match the index, opens on the README, copies docs/assets/, and builds with no warnings. The package files include docs/. test/documentation_links_test.exs checks every relative link, anchor, and image, that linked headings get the same anchor on GitHub and in ex_doc, the index sizes, the 600-line limit per topic file, and that every file under docs/ is an ex_doc extra.

  • Documentation audit round: docs/glossary.md (terms such as receipt, lease, baseline and profile, which mean different things in Live, the Lab and the load harness) and docs/cheat-sheet.md (the most-used observer commands) are new. The index has three areas (Use Insider Live, Lab and research, Production readiness and development) and new rows for hangs, pinned traces, response values, N+1 queries, Oban jobs, timelines, the baseline, the cleanup receipt, the default session, a node you did not start, and flaky tests. Long sections are split, so no indexed section is over 150 lines. The Live files gain command examples for every operation, a complete observer flag reference, a cleanup-receipt section, and a table of what each disclosure profile shows and withholds. The disclosure docs state that rich assumes development data holds no real personal data, and say to set :strict when it does. Current status is a set of tables. The README, AGENTS.md, the usage rules, and the architecture page use one product definition. The shipped docs and the welcome drop evaluation anecdotes and company examples. The docs tests now also check each topic file's back-link line and contents list, closed code fences, and section size per index row, and the readiness test rejects internal company, evaluation, and ticket names in the README, docs/, the guides, and the usage rules. mix docs copies the readiness JSON beside the pages, titles the people overview "Overview", orders the guides, and groups Insider.Lab.Output.

  • The welcome quick start's first step, mix insider.live --help, and the agent guide now say that stdout carries only the observer's JSON while Mix's Compiling and Waiting for lock on the build directory notices go to stderr, and point agents whose tool merges the two streams, or several agents in one checkout, to the insider-lab escript, which prints neither. A Lab test runs every machine-output task while another process holds the build lock and parses each one's stdout.

  • Coverage: on OTP 27, the modules that only run on OTP 28 and later (Insider.Collector.Calls, Calls.Tracing, and Otel.Tracing, which need isolated trace sessions) are left out of the coverage total, since only their requires_otp_28 refusal runs there. On OTP 28 and later they are counted, and the 90% floor is unchanged on every OTP release.

  • An inspection's session record that its caller stopped waiting for reports recorded nil with reason outcome_unknown, never false: the session refuses a record that arrives after its deadline, but one already handed to the Recorder may complete after it.

  • The observer's events and watch print a lean event envelope by default (--format json): each event drops the fields that are the same for every event (schema, node, boot_id, clock_id, source_instance_id, source_sequence, monotonic_time, authority) and those that are null or empty; --format full prints events exactly as the target returns them. Every insider.live-events/v1 batch now carries disclosure_profile, the profile its events crossed. The Live quick start has six core commands (digest after start), its recipes start with a triage digest, and each available symptom recipe reads with digest before events.

  • The observer's malformed-option code is invalid_options, the same name as the target's (it was invalid_option). Its details name the flag (option), the problem, the expected value or accepted flags (expected), and the help command; a target invalid_options passing through the observer gains the flag that set its field and that flag's syntax. The observer's own argument errors and non_loopback_host never echo a value, which may be a secret typed into the wrong place; errors the target returns pass through and can name a value they reject (such as unknown_telemetry_event's event). A quick start, recipe, or example command that no longer parses with the observer's parser fails the Lab suite.

  • A live read's "limit" and "max_bytes" now count only the events it returns, never the ones its view hid, and "max_bytes" counts their canonical JSON bytes rather than stored bytes; a read stopped by either ends just before the next event it would have shown, consuming the hidden ones in between. The view is applied event by event inside the read (Insider.Live.View.hides/2 replaces filter/2), so a sparse view no longer starves.

  • The observer's watch prints the envelope (schema, status, operation, target, installation, and the first-contact welcome) once, on its subscribed line, which also carries the subscription; batch and stopped lines carry only kind and their own fields.

  • mix insider.candidates no longer reports an empty, partial, or truncated scan as clean. The inventory is now insider.exunit-candidate-inventory/v2 with a completeness field (complete, empty_selection, unsupported_source, truncated); status is clean or candidates only for a complete scan and otherwise names the completeness state. New exits: 3 empty_selection (no _test.exs file selected), 4 unsupported_source (invalid syntax, a skipped symlink, or an unreadable path; candidates found are still reported), and 5 truncated (a file, byte, or candidate bound was hit). Failed scans (exit 70) add completeness: infrastructure_failure to the unchanged v1 error document. Candidate entries, fingerprints, and scanner_revision are unchanged.

  • The non-published Load project no longer starts an empty supervisor; dependency startup and its clean-revision evidence gate remain unchanged.

  • Insider.Event.validate_encoded/1 validates an event and returns its canonical binary from a single pass. Validating the aggregate byte bound already produces that encoding, so Recorder.record/2, Recorder.freeze/2, and incident source entry building no longer validate twice and encode three times per event. The recorder admission benchmark drops from a p50 of ~42.4 us to ~23.2 us per record on the development host, restoring headroom under its 50 us development p95 budget. validate/1 and canonical_binary/1 keep their existing signatures, results, and errors.

  • Recorder rate-window expiry now deletes stale ETS rows in place instead of copying every rate entry on each admission. In an eight-round development-host run at 256 keys, p95 admission fell from 32.90 to 27.35 us per record.

Fixed

  • A collector session start that ran past its budget now fails with a startup_failed receipt whose cleanup.startup is timeout, with start_budget_ms and start_elapsed_ms. When the session itself found its start authorization expired, the Manager returned the bare reason, so Live reported start_failed without a receipt (or, through another path, startup other). The session supervisor also starts before the Manager, so a start admitted right after a root restart can no longer lose its worker and leave the start slot held.

  • The Live quick start failed in zsh, the macOS default shell: the welcome, the hints, mix insider.live --help, and the docs set the target flags as one string, N="--node … --cookie-file …", and zsh passed the unquoted $N as one word (invalid_options, exit 64). They now set an array, N=(--node NAME@HOST --cookie-file PATH), and every generated command passes "${N[@]}". The watch example quotes its 'phoenix.*' view pattern, which zsh refused as a glob with no match. A Lab test runs every welcome example and every observer command line in the docs through bash and zsh, when present, and parses the words with the observer's parser.

  • Live trace and timeline read the session newest first. A recent request or trace is found in a long session even when the four-second budget ends before the oldest receipt (a timeline --request-id read from the oldest found 1,413 of 16,000 events and returned no items). A scan that ends early reports scan_truncated with the receipts it did not read, and scan gains direction and unread. Cumulative losses are the session's totals since it started, read by internal reads that ignore and issue no cursor baseline, so a page cursor another reader issued cannot turn them into a smaller delta.

  • Live bin_leak names the biggest binary holder first: the result's new biggest_holder is the process that still references the most binary bytes after the collection, and it sorts ahead of by_freed_bytes in the canonical JSON, where an agent reading the head of the document saw only the garbage list and concluded the leak was not named. --human (option "human") prints the holders first as plain text, then what the collection freed, and says when the evidence is incomplete (scan limit, unfinished collections, protected processes), never claiming an absence then; the text is at most 8 KiB and the result's lists are cut around it to the result bound.

  • insider-lab live calls no longer take 7-25 s on a loaded host. Two fixed costs dominated each call:

    • Booting a VM with one busy-waiting scheduler per core took 10-17 s before main ran at load averages of 100-160. The escript now embeds +S 2:2 +sbwt none +sbwtdcpu none +sbwtdio none.
    • The observer's own build identity loaded and hashed every Insider module on each call. It is now computed once at compile time (Insider.Lab.Live.ObserverBuild), and Mix recompiles it when the build changes.

    Measured against the same target: a capabilities call went from 14.6-19.9 s to 0.8-1.7 s at a load average of about 156, and from about 0.55 s to about 0.45 s at load about 24.

  • Tests run from a Git hook can no longer change the repository the hook runs for. Git exports GIT_DIR and GIT_INDEX_FILE to hooks, and git commands the tests ran in scratch directories acted on the real repository instead (on 2026-10-23 that set core.bare=true and committed to a real branch). pre-commit and pre-push now unset GIT_DIR, GIT_WORK_TREE, GIT_INDEX_FILE, GIT_COMMON_DIR and GIT_OBJECT_DIRECTORY before mix. Every test helper that runs git clears them for its child processes. So do the oracle runner's target listing and the load harness's revision capture. Each project has a regression test that runs its git-using tests with those variables pointing at a sentinel repository and checks the sentinel is unchanged.

  • --load no longer leaves a target on another build of the same Insider version. The observer compares build identities: the application version, the commit, and a SHA-256 over the loaded :insider modules' MD5s (new Insider.Live.Build). --load only installs: it pushes Insider into a target with no Insider code, or starts this build where it is loaded but stopped, and verifies that the target then reports this build. Any other build loaded on the target, started or not, is refused with the new load_build_differs error (exit 3). The error reports both builds, whether a session is active (or "unknown" when the owner does not answer), and the remedy: the new --force-load, which replaces Insider and ends any session. See decisions/2026-10-23_observer_load_only_installs_and_only_force_replaces.md. installation in every observer document now carries observer_build, target_build, same_build, and a remedy when the builds differ. The observer's insider_version_mismatch and insider_not_started messages, the welcome quick start, the README and mix insider.live --help say the same: --load installs or starts this build only, and replacing another Insider takes --force-load, after saving the session's evidence.

  • A Poller process scan on a busy node usually records the rankings it reached instead of a timeout with none. Each process_info/2 answer comes from its target, so the scan waited for every busy process to be scheduled: with four spinning processes per scheduler a scan of 3,000 processes took 2.5 s at the median, past its 1 s probe timeout, and CI once recorded a process_top with no rankings. A scan now stops issuing scan requests at 5/8 of its probe timeout (unavailable scan_deadline) and naming requests at 7/8 (process_names); one outstanding request can still outlast the timeout. An unfinished scan's Insider totals are incomplete, and the next scan gives a process it did not reach no reductions delta (reductions_delta unavailable) rather than its lifetime count.

  • A Lab contract invocation whose callback exceeded its deadline is reported as :timeout / :deadline_exceeded even when the caller handles the result after the dispatch deadline. Under load the caller could reach the result with no time left to release the runner, which had already stopped, and reported :executor_failed instead (a flaky ContractTest on the Lab 1.17 lane). The caller now confirms the runner's exit on the monitor it already holds before asking the executor to release it.

  • Recorder admission no longer spins. The writer next in line for the ticket lock looped on :erlang.yield/0 until its turn. A process that is always runnable keeps its scheduler from sleeping or taking work from another, so the host's own processes waited behind it. Every waiter now sleeps until its turn's release wakes it or a 1 ms poll ends, and a dead holder is passed on after 64 polls (nominally 64 ms). On GitHub's 2-scheduler runners the load harness's overload phase missed a 10 ms tick (50 operations) in 4 of 6 jobs before this change, and none after it; instrumented CPU time and garbage collections went back to what they were before the ticket lock. See decisions/2026-10-23_recorder_admission_waiters_sleep_and_never_spin.md.

  • Live otel draining is bounded and never silent. A read's drain stops at its one-second deadline even while spans keep arriving (it used to run past the read's call bound and return otel_accounting_unavailable) and leaves the rest pending for the next read. A seal or stop that cannot drain its backlog in time counts what it leaves as otel_abandoned, or reports otel_accounting_unavailable when even the count cannot finish, instead of discarding those spans.

  • Compiler progress no longer precedes Lab Mix task output on standard output. mix insider, insider.live, insider.oracle, insider.candidates, and insider.privacy_corpus compile the project first with Mix's progress (Compiling N files (.ex)) on standard error, so the first call after a Lab source change prints the same standard output as any other call. Output formats are unchanged. Every Lab task and the insider-lab escript write through one UTF-8-safe writer (Insider.Lab.Output), so non-ASCII text such as … no longer prints as ….

  • mix insider.oracle output redaction is bounded in time and memory. All passthrough values are matched in one scan that merges overlapping matches and writes each replacement straight into the output, and lines are filtered in one more pass, so no list of spans or lines is held: 64 overlapping values over a 1 MiB capture take about 150 ms and a constant heap, where before they exhausted a 16-million-word heap. Values over 64, over 1 KiB each, or over 16 KiB in all, more than 16,384 replaced spans, and a scan over its work budget fail closed: nothing is saved, output.txt states the reason, and the run record gets an output.withheld field that names it. See decisions/2026-10-22_oracle_runner_bounds_output_redaction_and_withholds_past_the_bound.md.

  • Live loss reporting across a stop or amendment. A component whose final status the seal could not read now leaves <component>_accounting_unavailable on every later read of the session, through later amendments and the drain window, while keeping the loss counts the copy before the seal had read. Boundaries a stop or amendment could not copy to the end are reported as at most one segment_end_unread gap per read, with "boundaries", from at most eight stored ranges, so the gap list stays bounded however many there are.

  • A Logger flood no longer evicts other sources' evidence. The Recorder reserves each event source a share of its events and bytes (source_shares and other_share; by default logger 25%, telemetry 15%, poller 25%, otel 10%, inspect 5%, system_monitor 5%, others 5%). When it is full, a source over its share evicts its own oldest entries, and a source within its share takes room from those over theirs. On a shop test target, rich Logger at info had filled the 4 MiB Recorder in about four minutes and evicted the early Poller samples. Protected entries keep their precedence. Insider.Recorder.fill/1 and status/1 report per-source usage and evictions under sources, and Live status under recorder.sources; the welcome describes the shares under recorder. These per-source counts and the cumulative evicted counter, now their sum, are conservative: an eviction is counted before its entry is deleted, so a writer killed in between can make them exceed the real evictions, never fall short. Receipt-range evicted gaps stay exact.

  • Insider no longer grows while serving large Live reads. A read is served in pages of at most 100 entries and 128 KiB (bounds.read_page_entries, bounds.read_page_bytes) and keeps only the events it returns, and the owner, Manager, and Session collect their garbage after replying. A 1 MiB read from a full Recorder peaked at 4.1 MB in the owner, 4.1 MB in the session Manager, and 7.7 MB in the Session, which kept 2.5 to 9.6 MB afterwards; it now peaks at 3.0, 0.14, and 0.29 MB over their collected heaps, and no process keeps anything of it (bench/live_read_memory.exs, which now also reads while the owner keeps stopped sessions readable and through an amended session's archive). Archive pages, and pages joining the archive to the Recorder, keep the same 128 KiB bound, counting archived entries by external term size. Live status reports Insider's own memory as insider_memory, and the collector session's read reply names the bound that ended a page as "truncated_by".

  • usage-rules.md and the agent guide no longer say payloads, Logger message text, and Telemetry metadata never leave the node in every profile; that holds only in strict, and rich is the development and test default. A drift guard keeps both documents in line with the welcome's disclosure defaults.

  • Credential masking no longer reads a port as a URL password: http://127.0.0.1:4100 at the end of a value, before a query or fragment, or inside inspect text, and IPv6 hosts such as http://[::1]:4000 stay readable, and an @ in a later JSON field never turns a port into a password. URL userinfo is now decided by a bounded, linear scan of each URL's authority that fails closed: real user:pass@ userinfo is masked whatever RFC 3986 characters it holds (apostrophes, ,, ;, ) and numeric prefixes included), userinfo without a password is masked whole, and a password a cut left at the end of a value or of a quoted value is masked. An ambiguous unquoted list such as http://h:4100,a@b is masked, and a provider key or JWT inside userinfo never hides the rest of the password. A port is one to five digits, and an authority longer than 2,048 bytes is masked whole up to its last @. An all-digit password of one to five digits cut exactly at its end reads as a port.

  • The observer delivers the welcome once per target node incarnation (its name and distribution creation), not once per node name forever: a restarted node, or a node first contacted after another, gets the quick start again. Printing welcome now counts as delivery, so the next command carries a pointer instead of repeating the document.

  • Live subscriber batches are contiguous: each starts at the previous batch's next_cursor. A poll whose view hid every event was not sent but advanced the subscriber's cursor, so the next batch began there and the hidden receipts fell outside every batch's range while its view counts included them (one agent report saw cursor 555 after next_cursor 516).

  • Concurrent Insider.Recorder writers no longer lose events to the admission lock (recorder_contended). Admission is now a ticket lock: a writer that finds the lock held waits for its turn and writers are admitted in arrival order, instead of dropping at once. A waiting writer sleeps until woken through a process alias that is drained before the call returns, so no message is left in its mailbox; dead holders and dead or abandoned waiters are passed over. A writer gives up, as :contended, only when the lock has not changed hands for the new start_link/1 option admission_stall_ms (0 to 5,000, default 1,000; 0 is a single attempt). The Recorder must be called from collector or other Insider-owned processes, never from application processes. Memory, size, event and rate bounds, receipt order, and loss accounting are unchanged. On a plain peer with Logger and Telemetry each emitting 600 events/s through one Live session, the base revision lost 152 of 3,592 events as recorder_contended and this change lost none; at 3,000 events/s each, only rate limits, inbox shedding and eviction lost events. bench/recorder_contention.exs gates the write path with 1, 2, 4 and 8 writers, timing every call against the same round's single writer: no contended loss, per-call p50 and p95 within margins of N times one writer's, and a minimum share of one writer's throughput, over the median of 8 rounds whose before-and-after probes saw no scheduler-thread preemption (an advisory screen: a pause inside a round goes unseen, so run it on an idle host); otherwise it exits 2 (inconclusive). The base revision lost about 90,000 of 128,000 writes with 8 writers.

  • Live Telemetry events that report a failure are now severity error, so a "min_severity" => "error" view keeps them: every *.exception event, and any event whose metadata has result {:error, _} or :error, conn.status or status 500 to 599, kind :error, :exit, or :throw, or a non-nil, non-false error. Live recorded phoenix.router_dispatch.exception and a 500's phoenix.endpoint.stop as info before. The rule (Insider.Collector.Telemetry.Outcome) reads only the event name and those shapes, never other metadata, and is the same one summaries use for errors and minimum durations use to keep errors. The welcome document gains a severity table generated from it and from the Logger level mapping.

  • A Telemetry measurement a live session did not select now leaves a drop record in the read entry's redactions (policy_id insider-live-telemetry), as the welcome's disclosure rules promise: it names the measurement when the host allowlist has it, and counts the rest without names; in the strict profile the uncollected metadata keys leave one counted record. Counts are exact. The core Telemetry collector records this evidence in each event's "omitted" attribute (never in the event's redactions, which stays the export manifest that incident capsules require to be empty), names withheld measurements only when they are in its new nameable_measurements option, records the counts alone if the names would not fit the attributes bound, and records the event without the evidence if even the counts would not, counting it as omissions_unrecorded (Live gap telemetry_omissions_unrecorded). The welcome's strict rules now say plainly that Logger content is not collected at all.

  • The observer's report queue moves from the system temporary directory, which a reboot can wipe, to insider-live in the user's durable state directory (~/Library/Application Support on macOS, $XDG_STATE_HOME or ~/.local/state elsewhere); INSIDER_LIVE_REPORTS_DIR still overrides it. Reports filed with pre-release builds in $TMPDIR/insider-live are not carried over or read; the queue there was never released, and a person can still open observer-reports.jsonl in that directory by hand.

  • Report context carries the observer's last local failure (last_local_operation, last_local_error_code), such as a usage error, beside the last target operation; the issue body labels both. Queued records without these keys are read with them as nil.

  • scripts/verify-load-evidence fails closed when manifest.json or report.json is not byte-identical to its canonical encoding, reporting manifest_not_canonical or report_not_canonical with ok: false. It used to skip identity recomputation and still report ok: true for such files, so a manifest with a substituted id and digest plus a trailing newline passed. id_recomputed is now true whenever ok is.

  • A startup worker that dies after child admission now keeps the session start slot quarantined until the session root resets; a second session cannot take ownership of an unreported child.

  • The Load harness stages bounded artifacts in restricted private directories and publishes them exclusively. It leaves foreign or partial public files intact on publication failure and emits a verified failure-only artifact when output remains empty. Git status has a hard elapsed-time bound, and profile and lockfile reads have byte bounds.

  • Lab's advisory ExUnit scanner tracks Application shadowing by module and declaration order even when unsupported aliases disable key resolution. It no longer credits shadowed or repeated application-environment deletion as restoration and rejects malformed scan options and repeated scalar CLI switches without rejecting repeated paths.

  • Lab minimization preserves the cleanup observation that stopped a search, emits verifiable one-run baseline evidence on quarantine, and retains exhausted or nondeterministic evidence when a later cleanup check fails.

  • Lab bisection stops an index as probe_inconclusive on its first unclean confirmation instead of spending a second. Two probes that failed before observation produced one content-addressed confirmation record twice, which no trial may reference, so the search returned invalid_bisection_record with no record at all. Record validation accepts a one-attempt inconclusive trial only when its single record is itself unclean.

  • scripts/verify-production-artifact now boots the release through bin/insider. It used to run the first executable in bin/, which on Linux can be the Windows insider.bat, so the gate failed on every CI runtime.

  • The external-process cancellation test now preserves cleanup_uncertain as an honest bounded outcome, binds its exact Linux descendant to the owned process group, and separately proves fixture reclamation instead of treating an arbitrary later disappearance as part of the library verdict.

  • The Poller failure-accounting regression now reserves its maximum bounded cycle window for two deliberate provider failures, so unrelated scheduler contention does not ordinarily turn the second failure into a valid truncated probe.

  • The normal-exit process-group test now creates its work deadline inside the executing task and observes pending completion without extending the wait, so scheduler admission is not charged to the descendant-drain assertion.

  • Contract lifecycle tests now give asynchronous callback-start handshakes the same explicit bounded second used by adjacent capacity and termination assertions, avoiding the implicit 100 ms scheduler-contention flake.

  • External process execution now survives caller death long enough to terminate and reap the complete owned process group instead of orphaning its BEAM child. Negative process-group probes and signals use a portable option boundary, and cleanup waits boundedly when the direct port exits before its last descendant.

  • Restart-capture continuation tests now retain strict event ordering while allowing a bounded second for lifecycle notifications on constrained CI runners.

  • Identity-bearing host commands now hash stdout separately from platform diagnostics, preventing stderr warnings from changing an otherwise identical code or patch digest while preserving nonzero-status failure.

  • Logger and Telemetry hot-path benchmarks now fail when they exercise a rescue path, violate latency budgets, or fail exact admission/shedding accounting.

  • Contract invocation now synchronously releases its completed supervised runner before returning, so sequential callbacks cannot be falsely shed as overload while the executor is still reconciling the prior child exit.

  • Poller deadline verification now coordinates an active probe before advancing the absolute deadline, eliminating a scheduler-dependent test race while asserting the exact number of probes started and truncated.

  • Sandbox execution now reserves a caller-declared bounded provider-cleanup phase independently from body stopping, and protocol/scenario duration bounds can explicitly authorize target-application verification up to ten minutes while retaining the five-second default.

  • Restart capture now accepts a correlated terminal result during recorder admission and drains the owner's following DOWN, so a deadline before readiness is not misreported as owner failure or left in the caller mailbox.

  • Made the local coverage gate generate the same threshold summary and HTML evidence with bounded file-descriptor use on macOS and Linux.

  • Executor shutdown now gives active sandbox worker termination and owner-scoped cleanup a shared bounded drain phase before the lease registry exits, directly cancels blocked cleanup process trees, reports termination that remains unconfirmed, and quarantines unconfirmed target work.

  • Detector errors now discard hostile invalid Event IDs instead of copying unbounded or invalid UTF-8 identifiers into diagnostic output.

  • Logger fixture capture now uses a bounded collector flush barrier, preventing freeze and snapshot from racing an asynchronous collector drain.