docs(chat): record the live-run thinking open and the above-viewport anchor rule
docs(chat): record that every render style shows the card's facts - A style is a frame, not a capability: the generic body, the `Full output` chip and the reminder badge now reach compact, trace, minimal and tui through `hasGenericBody` and `ToolRowActions`. - The trace node's `warn` tone separates an aborted call from a running one. - Measured at 390 and 1440 on the 41-call sample: all five styles render every row with scrollWidth === clientWidth.
docs(chat): record how a worker's outcome is reported and drawn The measured reasons behind the orchestration fix: omp's flat error fields, the compacted terminal frame, the retry saga that must not report per attempt, the two ACP gaps (an `omp-acp` failure that arrives as ordinary text, and a turn that never settles), and why Kabmo's own three prompts carry an envelope instead of rendering as the operator's bubbles.
docs(chat): record the dispatch-window prompt_result leak - The suppression rule is the whole run, not its streaming half: `streaming` flips at `agent_start`, so a background command answered between the prompt's dispatch and its first frame reached the client and settled the optimistic turn. - Measured on omp 18.22.2: the plan-review `republish` fired on spawn adoption reached the child 43 ms after the prompt and was answered `agentInvoked:false` 160 ms before `agent_start`; 57 of 58 first prompts rendered the user turn twice, 0 of 50 after the guard.
docs: record the shared fullscreen viewer for pictures and diagrams
docs(chat): record the jump's own motion and the composer-growth pin - The open jump re-aims with the behavior it was given; re-aiming smoothly turned it into a ~700 ms animated scroll (measured: scrollTop 14 109 -> 16 033 over 21 frames, mounted rows 16 -> 19 -> 7). - The composer's growth is a layout effect and a container resize is pinned inside the ResizeObserver delivery; content growth stays deferred (measured: 22 px of the last row past the scroller's edge for one frame).
docs(dictation): record the per-shell capture wiring The page's `getUserMedia` is one call; the host is what differs, and each platform fails silently in its own way. Android needs MODIFY_AUDIO_SETTINGS (a NORMAL permission nothing in the app references), macOS needs NSMicrophoneUsageDescription plus the capture delegate, Linux needs enable-media-stream plus an answer to `permission-request`, iOS was already correct, and Windows relies on WebView2's own prompt.
docs(chat): recorded why ASCII box art skewed in a markdown code block `symbols2` is not a language subset: it is the only one carrying U+2500-259F, so trimming it left box drawing to the system `monospace` fallback at 8.502px against Fira Code's 7.2px cell. Records the measured numbers, the `unicode-range` that keeps the files off the wire, and that the decorative symbols are still off-grid by design.
docs: record why the highlight memo keeps two shapes per key A block highlight is one inline string and a line highlight is one fragment per line; one slot for both made a 7-line JSON block render as a single row beside seven numbers. Measured on the Linux gate of run 43389433332.
docs(chat): document the composer's ArrowUp prompt recall Records why the recall list is its own table instead of a transcript scan, where prompts are recorded (the HTTP boundary, not the RPC dispatch), the cursor rules, and the browser verification against a temp database.
docs(chat): record why a rail tick names the mounted row's id The jump rail listed the id omp committed for a turn before the client's optimistic bubble was reconciled to it, so a click on the turn just sent revealed nothing until a reload. Document the rule (committed index + mounted row id, bounded to entries newer than every mounted committed turn), the measured evidence from this install, and the reason the newer-than bound exists.
docs(chat): record how omp 18.18.9 delivers peer messages A message that ends a `wait` is no longer a result field: omp hands it to the session, which injects an `irc:incoming` turn, and the wait answers with `interrupted: true`. The turn's content is the `<irc>` prompt envelope, so the transcript mappers read `details.from`/`details.message` and the timeline draws `IrcNotice`; the wait card's `waited` block survives only for JSONL recorded on 18.17.0-18.18.6. Measured on a persisted entry: `details` is `{id, from, message}`.
docs(fork): record the per-harness fork point and the button's gating Standard ACP has no fork point; claude-agent-acp and codex-acp read the AIR _meta.jetbrains.air.fork extension, omp is cut on disk, and the rest fork the whole session. The page now carries the measured table (advertised fork, fork point, transcript store, Kabmo path) and the rule that canForkAt gates the row button, so a future reader does not re-add a control the send path refuses.
docs(chat): record why a live run row must carry the model The docked indicator showed `Loading…` during a stream for two reasons, and both are now pinned: the client discarded known session metadata whenever the live row had no pair, and the row could genuinely lack one because the frame fold wrote the status alone.
docs(chat): record why a fork renders the history it continues The two halves of the fork transcript — the pending preview and the prefix prepended at adoption — exist because the timeline cannot read the branch on its own while the page's own run owns the rows. Naming the cut rule, the read-only row treatment and the measurement keeps a future reader from "simplifying" the preview back to an empty composer.
docs(omp): record the 18.18.6 wait sentence and the schema source cache The `wait` parser accepts both the 18.18.3 trailing period and 18.18.6 back-to-back hint, including the new `No job finished` subject. The schema generator now version-checks its package against the pin and provisions a miss into `$XDG_CACHE_HOME/kabmo/omp-schema/<pin>`, so a standalone-binary machine needs no global `bun add -g` (which collides with the binary on EEXIST) and keeps one `omp` command.
docs(chat): record why the generating indicator rides one dock frame The pending `new-…` branch and the real timeline used to spell the dock out separately, so the indicator sat 28px higher while the spawn was in flight than once the run streamed (measured 141px vs 113px above the pane's bottom at 1200x1400 with the built CSS). Documents the single `ComposerDockFrame`, the transcript box it shares with `TimelineBody`, and the test that pins it.
docs(chat): record the inline-code chip fill rule and its measurement The chip was a `color-mix(… transparent)` alpha, so any hover tint painted behind it changed the code's colour. Adds the measured before/after, the palette token that replaced it, and the lightningcss fallback it removed.
docs(harness): record ACP rewind and New Chat harness inheritance The Undo/Retry rule is a capability, not a transport: `omp-rpc` and `omp-acp` share the session JSONL, and the endpoint tears a live ACP child down before truncating. The other ACP agents are refused before their child is touched. New Chat captures the source chat's harness on open and carries it into the first spawn, so an answer from an ACP agent does not start an omp-rpc chat; the omp prewarm is skipped because its pool only holds RPC children.
docs: record that omp 18.18.0 gates the shell trace on a setting The trace bullet said the field arrives whether or not anyone draws it. That was true on 18.17.0; 18.18.0 gates it on `display.shellVisualization` (default true), so it arrives unless an operator turns the row off. Kabmo's strip does not change, and the measurements stay labelled as taken on 18.17.0.
docs: record omp 18.17.0's wait windows, message list and shell trace Three measured rules the bump depends on: - a blocking `wait` has no 30-minute ceiling any more; the window comes from a 5 s / 10 s / 30 s / 60 s / 5 min ladder and both the rung and the streak are only in omp's prose, which is why `wait-idle.ts` parses it; - `details.waited` is a list, and the single-object shape a pre-18.17 session keeps in its JSONL is still read; - the embedded shell's trace rides every `bash` frame (192 KB of frames for 40 output lines, 9.2 MB for 120 over 73 s, 201 KB in the JSONL for `seq 1 30000`) and is dropped at the fan-out and on transcript reload. Also notes the trap that cost an hour: the schema generator reads the npm PACKAGE, not the `omp` binary, so a self-updated binary still regenerates the old schema until the global package is installed at the new version.
docs(chat): record the indicator mark and why it came back The ring was dropped for the chroma rule and the replacement shipped with no motion, so a busy row read exactly like a settled one. The bullet names the measured consequence, the class that carries the gradient, and the reason the spin rides `.animate-spin` (the reduced-motion block slows it instead of freezing it).
docs(chat): record the follow-up queue's ordering and busy-refusal rules The queue's reordering bug and its 2s redispatch loop were one story: two delivery attempts claiming heads at once, a requeue that recomputed the head from MIN(position), and a wrapper that stayed "idle" through omp's own agent_busy refusals. The page now carries the measured numbers (positions 0..7 walked to -8..-1, 104 refusals in one session) and the three rules that prevent them, so the next change to the delivery path does not reintroduce them.
docs(rpc): record the inbound ceilings, chunk recovery and abort verdict The RPC page claimed the transport was fully described. Three measured facts were missing, and each one is the reason a rule in the app exists: - The inbound ceilings come from `ready` and a damaged chunk sequence now costs one frame instead of the child. Includes the sizes that make this matter: `get_available_models` at 522 KB and a 3000-item `set_todos` at 1.33 MB, delivered as 6 chunks with a 349,629-byte largest physical line. - An aborted run is identified at `message_end`, not `agent_end`, because omp trims the terminal frame. 12.7% of the runs in the author's store exceed the ceiling that triggers the trimming.
docs(chat): record why outbound RPC frames must stay on one line A prompt carrying a >1 MiB image was silently dropped: protocol v2 chunking is the wrong direction to reuse, because omp's rpc-ui stdin loop rejects every `rpc_chunk` record. Records the measurements (both omp versions, the ack latency of a single 30 MB line), the separate ack budget an image prompt needs because omp describes the image before answering, and the attachment limits that must stay in step with the outbound ceiling.
docs(transcript): record the tui tool style and the two defects it measured The tool-render section listed four styles and their density table. `tui` is now the fifth, and the page records why it is text rather than a card: omp's terminal writes a call as a status line, so the row measures `border 0px / transparent / radius 0px` at 22px and the body hangs off a hairline rule. Two defects are stated with their measurements, because both were invisible to a class-level reading: - `text-meta/85` is not generated by Tailwind (only `.text-meta` is in the bundle), so the subject fell back to ink and matched the tool name — the exact "title and subject look the same" report. - The facts group was unbounded and widened the section at 390 to `scrollWidth 459 / clientWidth 362`; capped and clipped as a unit it now measures 362/362 at 390 and 720/720 at 1440. The expand wording, the `▸`/`▾` affordance, the per-call intent heading and the e2e selectors they serve are recorded as properties of the style, and `blockChrome`'s `frame` is named as the one place that decides whether a block is framed.
docs: record omp 18.16.0's minimized bash output The shell minimizer rewrites verbose `bash` output and records the rewrite in `details.meta.minimized`, with the lossless original saved as `<id>.bash-original.log`. Name the field shape, the measured numbers (`10970 → 3905`, filter `git`), why the chip outranks the line count, and why `artifactRefOf` must prefer the minimizer record over a truncation record. Also refresh the schema line: 438 upstream entries, `10 tabs / 582 settings`, 461 merged keys, all accepted by `omp config list --json`.
docs(chat-stream): record that a job row leads with the model's intent omp 18.15.0 records the caller's `i` intent on the job and prints it before the command line. Both Kabmo cards parsed `label` alone, so the purpose was dropped. `jobSubject` is the one resolver behind the wait row, the proc row, the cancelled rows and the wait card's header; measured with the release's own `snapshotJobs`.
docs: pin the bottom-jump landing rules The scroll-to-bottom button stopped part way for four separate reasons, and each is now a rule with the measurement behind it: the settle guard is geometry rather than a timer, an upward scroll only counts as the reader's when real input produced it, the jump is the only writer while it lands, and a dropped smooth animation is re-aimed instead of abandoned.
docs(chat): state why a block's open state is session state The accordion's openness lived in a local `useState` while the timeline mounts a window of rows, so an expand could unmount the very row that held the block and it came back closed. Record the measured symptom (3 rows removed and re-added per expand on a 14-row session, surviving only while enough content sat below the row), the two window bugs that fed it, and the rules that replace them: the reader's choice is persisted per session and per block id, a measurement corrects the scroll in the same commit, and a running reveal owns the viewport.