204 Commits

Include renames

Author	SHA1	Message	Date
Wsyjq	70226149ce	fix(chat): pin existing-session sends to captured target (#2424) ... * fix(chat): pin sends to captured session * fix(chat): handle runtime cancellation consistently	2026-08-07 00:46:21 +03:00
Bohdan Triapitsyn	237cae16b3	fix: stop the composer re-sending a queued message already in flight ... A queued message is removed from the queue only after its send resolves, so between dispatch and resolution it stays visible to every reader — and a composer submit merges the whole queue into its own send. Over a relay that window is seconds, long enough to deliver the same message twice. The queue now tracks which entries are awaiting the server. Dispatchers skip them, clearQueue retains them so the pending send can still remove or restore its own entry, and the flag is not persisted because a restart has no in-flight sends.	2026-08-03 23:14:14 +03:00
Bohdan Triapitsyn	17c2d5ec36	fix(ui): keep diff refreshes targeted	2026-08-02 21:46:22 +03:00
Bohdan Triapitsyn	96c011a8ef	feat(mobile): tablet layout pass and foldable-ready size class (#2569) ... The tablet ran the phone layout with a half-finished iPad draft on top: two custom sidebars, a leftover overflow menu, split Files/Changes header buttons, and phone-width sheets stretched across a 13" screen. This brings it onto the phone's navigation model and keeps only the differences a large screen earns. - Sessions are a persistent resizable left sidebar; the overflow menu is gone and its destinations moved into that sidebar's footer (connected instance, settings, pending web update) and into the workspace drawer. - The workspace (Changes / Files / Terminal / Notes / MCP) is the phone's drawer everywhere: a resizable right sidebar where the screen can host one (up to 900px) and the full-cover drawer otherwise, with its mounted panes — an open diff, an edited file, an attached terminal — surviving rotation. - Header dropdowns are anchored popovers: the recents switcher mirrors the usage overlay on the left, and its trigger is sized to the title rather than to the free width. - App-level pages (settings, instances, update, an opened plan) render as centered dialogs instead of covering the screen. - Overlays center on the chat column through published insets, so the model and directory pickers no longer sit off-centre; the directory picker also stops overriding the shared width clamp. - Wide chat layout applies to mobile surfaces, where a tablet chat column is finally wide enough for the setting to mean anything. The layout gate is a live size class rather than a device check, so Android tablets and foldables are covered by the same code: - `enabled` when the shortest viewport side is at le sw600dp). The short side is what makes this a size question instead of a device question — a phone reports ~360-430 whichev unfolded book foldable ~600+, and folding shut drops back under it. iPads also answer on identity, since iPadOS hands out od - `roomyForPanels` when landscape and at least 1000px wide, which is what it takes to host the sidebar, the panel and a readabl foldables miss it in BOTH orientations — their long side is barely wider than a tablet's short one — so they keep the portr Every consumer re-decides instead of remembering wha open sidebar closes if the device folds shut under it. iPad behaviour is unchanged: its landscape widths all clear the panel ones do not, exactly as the previous orientation check did. Hardware keyboards are read natively. iOS reports them through GCKeyboard, published to the web layer at document start and kep disconnect and foregrounding; the layer stops inferring once that answers. A single early publish was not enough — the connect no already-attached keyboard fires before the page exists, and GameController can populate late — so the state is re-published across resume. With a keyboard attached the draft screen keeps its starter chips and the composer never collapses; tablets skip the colla Runtimes with no native answer fall back to inferring it from the keyboard bridge, and only ever conclude "hardware" from silen Also: sidebar rows no longer sit on a differently ti footer is no longer clipped by an over-tall content box, the resize handles moved above the panes' own overlays so they can actu now-unreachable overflow menu, fullscreen terminal/MCP/notes surfaces and their locale key are deleted. Device behaviour is unverified — the tablet layout, keyboard bridge and the foldable size class have not been exercised on hardware, and the 600/1000 thresholds are derived fr rather than measured on a foldable.	2026-08-02 16:25:16 +03:00
Bohdan Triapitsyn	86ef96302d	feat(mobile): mobile app navigation rework and beta-feedback closeout (#2561) ... Navigation model rebuilt around two full-width drawers and a minimal header (sessions / title-switcher / usage ring / workspace): - Left sessions drawer: cross-project tree with live status indicators, swipe actions on sessions (rename/archive/delete) and on group headers (project edit / two-step close, worktree delete), reorder-only edit mode with collapsible project cards and draggable worktrees, app-level footer (connected instance, settings, pending web update). - Right workspace drawer: Changes / Files / Terminal / Notes / MCP as pill tabs (inactive tabs icon-only); panes stay mounted once visited. The full desktop file editor serves the Files tab; read/skill tool taps in chat open the file there at the requested line. - Header session switcher on title tap: 10 cross-project recents with live busy/attention indicators and project · branch metadata; the usage ring opens a metadata overlay with an explicit loading state. - The overflow menu is gone on phones (its destinations moved into the drawers); iPad keeps it until its dedicated layout pass. Correctness and continuity: - /auth/session answers bearer-first, so a stale WebView cookie can no longer mask a revoked device token; cold launches classify failures fast and land on an explicit connect screen. - Authoritative session snapshots raise frozen ordering baselines and stale live ranks — recents stay truthful after the app slept. - Cold launches reopen the last active session per instance (persisted pointer, confirmed against a sessions snapshot; a user-opened draft clears it), with a logo hold instead of a draft flash. Also: collapsed pill composer gains the stop control; chat tool rows share one 36px rhythm; Task subtool rows truncate; larger bottom safe area so the composer clears big-screen corner radii; Capacitor build hides About/Update (store updates apply there); widgets link to the sessions drawer with a list icon; MobileApp split into focused modules; five mobile-surface detectors unified; translucent borders normalized to 70%; all new strings translated across the 10 locales. iPad and foldable layouts are intentionally untouched - separate next version PR.	2026-08-01 21:16:36 +03:00
Bohdan Triapitsyn	4a56527d1b	fix: pass draft starter text as command arguments	2026-07-29 18:32:26 +03:00
Tom Rochette	d50cb5becc	fix(ui): deny open permission prompts on send (#2445) ... Sending a message while a permission prompt is open now denies every pending permission in the session subtree (optimistically, then formally via permission.reply reject) and queues the message for next-turn delivery, mirroring the question-dismiss path from #1740. - Add dismissOpenPermissionsForSession plus isPermissionRequestNotFoundError and removePermissionRequestFromChildStores helpers to session-actions - Extend dismissPermission with not-found cleanup, parallel to rejectQuestion - Wire handleSubmit to deny permissions and dismiss questions together, queueing once if either prompt type was open - Add unit tests mirroring the dismissOpenQuestionsForSession suite Closes #1958	2026-07-28 17:36:00 +03:00
Bohdan Triapitsyn	e2fa7dbad2	feat(ui): context panel 2.0 - surface rail, changes-first git view, live PR surface (#2418) ... * feat(ui): add context surface registry and rail switcher * feat(ui): move git and project notes into context surfaces, embed editor file tree * feat(ui): replace right sidebar with context surfaces, per-surface panel widths * refactor(ui): retire legacy main-tab overlays and right-sidebar state * feat(ui): rail polish, right-docked file tree, terminal surface * feat(ui): move terminal into context surface, per-surface tab closing, editor empty state * feat(ui): tune default rail order and activity dot * fix(ui): keep context panel controls anchored during width animations * feat(ui): lazy-follow context panel resize with window-level drag tracking * feat(ui): panel dividers, right-dock tree icon, muted outline folder icons * feat(ui): restructure git view into changes-first surface with standalone PR surface - Remove commit/update/pr tabs; git view is always changes + commit - Promote pull request to its own rail surface with shared repo context - Move update-branch and re-integrate flows into separate dialogs - Add PR status chip and repo actions menu to the git header row - Seed new PR-status entries from resolved sibling remotes to avoid a false "checking status" state when the PR is already known - History/graph dialog refresh button, fingerprint global identity icon, muted outline folder icons follow-ups * feat(ui): progressive-disclosure PR surface with live checks and pinned chat context - Segment the PR surface into Overview / Checks / Comments pill tabs with live badges; merge controls move to the status row - Live checks segment: progress bar, per-run rows with workflow names, elapsed timers, expandable failures, auto-refresh while pending - PR comments and failed checks pin as chat-context drafts (like terminal selections) instead of sending an immediate message; works on new-session drafts too - Shared prContext cache client+server, ETag conditional requests in the octokit wrapper (304s bypass rate limits), extended checks aggregate (inProgress/queued/startedAt) - Resolve gh-CLI auth login for merge-permission checks - Full-width description editor with matched control heights * fix(ui): single source of truth for PR checks and status readers - Derive the checks aggregate from the visible run list and sync it into the PR-status store so bar, badges, header, and git-view chip agree - Route PR body hydration through the shared context cache - Git-view PR chip reads the freshest entry across remote keys * fix(github): freshness stamps prevent stale cache responses from regressing PR state - pr/status and pulls/context responses carry a server-side fetchedAt that survives cache serves - The status store rejects responses older than the held snapshot (only clearing the loading flag), and the checks sync adopts the context's stamp so stale status polls cannot flip fresher derived checks - Regression test for the stale-response guard * perf(github): repo-level pull-list cache collapses per-branch PR resolution - One pulls.list per repo per state per 45s answers every branch (10 worktrees = 1 call, not 10 query fans); in-flight fetches coalesce - A complete repo list makes a no-PR miss authoritative, skipping the per-owner head queries AND the Search API fallback (the 30/min killer) - force refresh bypasses the repo list cache; PR create/merge/ready invalidate it * perf(github): back off Search API misses per repo+branch A branch without a PR re-searched on every poll; with >100 closed PRs the list miss is never authoritative, so the search fallback still ran and burned the 30/min search quota. Remember misses for 10 minutes; PR creation clears remembered misses for the repo. * fix(github): dedupe re-run check runs to the latest per (app, name) listForRef returns the superseded completed run alongside its re-run; GitHub's UI shows only the latest per name. Mirror that in both pr/status and pulls/context so counts and run lists match github.com. * fix(ui): address review findings on registry test, surface docs, and PR-context keys - Rail-order test asserts against the registry itself (was stale after the 'pr' surface landed and failed) - surfaces DOCUMENTATION.md describes actual behavior: has-content surfaces hide until content exists; only multi-instance/terminal panes are keep-alive, singleton surfaces remount and restore from stores - PR-context cache keys are runtime-scoped JSON tuples; invalidation compares the directory exactly instead of by string prefix (+ test) * fix(ui): wrap long unbreakable tokens in check-run details Annotation messages with long SHAs/URLs overflowed the panel; break-words on annotation title/message/rawDetails and output summary/text, and the expanded run body clips instead of widening the panel. * fix(ui): busy state for context-attach buttons and honest attach labels - 'Attach failed checks' / 'Attach all to chat' show a spinner and disable while the context request runs (previously nothing happened for seconds) - Action labels/tooltips reworded from send-to-agent to attach-to-chat semantics across all locales * fix(i18n): Ukrainian attach wording uses 'прикріпити' with proper cases * fix(ui): runtime-scope PR-view remote caches, correct surfaces doc on preview - Remote/remote-url caches in PullRequestView are keyed by runtime + directory so a backend switch never serves another runtime's remotes - surfaces DOCUMENTATION.md: preview is not keep-alive; preview tabs remount on switch like singleton surfaces * fix(ui): rail active color, clearer collapse icon, remove dead bottom-terminal dock Design-review feedback on the context panel: - Context rail: icons enlarged 16px -> 18px; the active surface is now highlighted with the primary color only (no background, no scale animation), replacing the previous scale-up effect that read as a resize rather than a selected state. - Files tree: the icon-only 'collapse all folders' toolbar button now uses collapse-vertical instead of contract-up-down, which was easily mistaken for a close button. The labelled 'Collapse all' dropdown item in the session sidebar keeps its icon since text removes the ambiguity. - Terminal: removed the leftover bottom-dock expand/close buttons that rendered in the context-panel terminal but controlled a dock that no longer exists (nothing toggles it anymore), so the expand button appeared to do nothing and duplicated the panel-header fullscreen control. Cleaned up the entire inert layer with it: four useUIStore fields (isBottomTerminalOpen/Expanded, bottomTerminalHeight, hasManuallyResizedBottomTerminal), five actions, their persistence, the MainLayout resize listener that only served the dock height, the dock-driven refit effect in TerminalView, and the terminalView.bottomDock.* keys across all 10 locale dictionaries. Validated: ui type-check and lint clean; messages parity test (2 pass) and useUIStore contextPanel test (13 pass) green; icon sprite regenerated via icons:generate. * refactor: use PR visual state for git header icon Derives the pull request icon color from a single visual state Covers merged, closed, draft, blocked, and open PR states Removes conditional class handling from the git header icon	2026-07-27 23:07:42 +03:00
Bohdan Triapitsyn	005b2e61b0	Composer: CodeMirror editor, unified prompt language, ChatInput decomposition (#2419) ... * refactor(ui): unify composer @mention grammar Extract the composer's @mention rule into composer/language/mentions.ts and route highlighting, send-time extraction, backspace-deletes-the-mention and the file-path check through it. The rule previously lived as four separate regexes in ChatInput.tsx with divergent cleanup, so every new reference type had to be taught to all four. Bracket handling is now symmetric: [ and { were accepted before @ but ] and } were not stripped from the tail, so [@plan] resolved to the name 'plan]'. Add characterization tests for the markdown tokenizer, which had none, to pin current behavior ahead of the editor migration. * refactor(ui): unify composer slash, snippet and trigger grammar Extract /skill, /command and #snippet scanning into composer/language/prefixTokens.ts, and the rule deciding which autocomplete a caret asks for into composer/language/triggers.ts. Each sigil previously had three separate implementations: one for highlighting, one for send-time collection, and one for opening the picker. They disagreed on the valid character set — the send-time skill scanner accepted only lowercase names, so a /My_Skill token was painted as a command but never collected. Scanning is now generous and membership in the command, skill or snippet registry is the authority. resolveAutocompleteTrigger replaces the 90-line branch chain in updateAutocompleteState with a pure function, keeping the previous command > skill > snippet > mention precedence. * refactor(ui): tokenize the composer in a single pass Add composer/language/tokenize.ts as the one entry point producing every highlight range from the text plus what the composer knows about the workspace. It replaces six independent memos in ChatInput.tsx that each re-scanned the same string for markdown, fenced code, mentions, slash tokens, snippet tokens and attachment citations. Mentions now distinguish the reference span from the raw token: 'see @a/b.ts,' highlights @a/b.ts and leaves the comma as sentence punctuation, while backspace still deletes the whole token so a wrapping bracket is not orphaned. * feat(ui): add the CodeMirror composer editor Add composer/editor: a CodeMirror view that renders the prompt language as mark decorations, and a controlled React primitive around it. The composer previously painted a transparent textarea over a mirror div, which restricted highlighting to styles that do not change glyph advance width -- so bold and italic were impossible and the overlay was disabled outright on mobile, where wrapped text drifted from the caret anyway. CodeMirror owns the text and the caret together, removing the second layer. The document stays a plain string, so nothing downstream has to serialize a rich model back into a prompt. Split resolveHighlightSegments out of buildHighlightParts so the mirror overlay and the editor decorations share one priority resolution. Not yet wired into ChatInput. Editor rendering is unverified: the package has no DOM test environment, so only the state-level extension is covered. * refactor(ui): move the composer onto the CodeMirror editor Replace the transparent-textarea-over-mirror-div composer with ComposerEditor. The mirror is gone, and with it the constraint that highlighting may only use styles which do not change glyph advance width, and the mobile carve-out that disabled highlighting entirely because wrapped text drifted from the caret. Removals the editor makes unnecessary: - measureCaretInTextarea, 46 lines of hand-built text mirroring for popup placement, replaced by the editor reporting caret coordinates - adjustTextareaHeight and its two layout effects, replaced by the editor sizing itself; the dictation transcript height is now an explicit floor - getInsertedTextFromChange, which diffed old against new text to recover what a paste inserted; the editor reports the change directly - the highlight mirror element, its scroll-sync and its parts memo - a _commandMetadata property stashed on the textarea and never read Caret placement no longer needs a requestAnimationFrame after a text edit: text and selection travel in one transaction. Runtime behavior is unverified -- the package has no DOM test environment. Type-check, lint, the 295 chat tests and a production web build pass. * refactor(ui): extract composer text and path helpers Move the composer's text-splicing rules to composer/text.ts and its path handling to composer/attachments/filePaths.ts, with tests. None of this logic was covered before, despite handling VS Code drop payloads, percent-encoded file URIs and Windows drive letters. normalizeDroppedPath and toProjectRelativeMentionPath were useCallbacks that closed over nothing but their argument and the search directory; they are now plain functions taking the root explicitly. * refactor(ui): make the composer's slash commands a table Nine of the composer's local commands did the same thing -- render a visible magic prompt plus synthetic instructions and send them as one message -- and that shape was written out nine times as an else-if chain. Adding a command meant copying twenty lines and remembering to change every string. composer/submit/slashCommands.ts holds the commands as data and the shape as one executor; ChatInput keeps only the five that manipulate session state or open UI. The command names, prompts and failure toasts are now typed against the magic-prompt and i18n key unions, so a mistyped key fails to compile rather than failing at runtime. Net: 257 lines of branching become 68. * refactor(ui): move the composer's footer components out of ChatInput RevertedMessageDock, ComposerAttachmentControls, PermissionAutoAcceptButton, FocusModeButton and ComposerActionButtons each own a piece of the composer chrome and were defined inline above the 4500-line component. They now live under composer/ui with the imports they actually need. Pure moves; getRevertedPreview travels with the dock, its only caller. * refactor(ui): extract composer draft persistence Move the draft lifecycle -- identity switching, debounced writes, external deletion, and the flush-on-hide/freeze/pagehide edges -- into composer/state/useComposerDraft. It was seven interleaved effects and five refs sharing state through the component body, which made the ordering constraints between them (skip the next debounced write while restoring; record the empty signature before a queued write can resurrect a deleted draft) invisible. They are now stated where they apply. * refactor(ui): extract drop payload inspection hasDraggedFiles, collectDroppedFiles and collectDroppedFileUris were useCallbacks with empty dependency arrays -- pure DataTransfer readers wearing React clothing. They move to composer/attachments/dataTransfer.ts with tests covering the host differences they exist for: browser File lists, VS Code's proprietary tree types, OpenChamber's own internal-drag marker, and getData throwing during dragover. * refactor(ui): extract the mobile composer shell Move the pill state machine into composer/state/useMobileComposerShell and the visual-viewport pinning into composer/state/useMobileViewportPin. Between them they held eight refs, four pieces of state and eleven effects interleaved with the rest of the composer, which hid what they are: not one state machine but a state machine plus a set of corrections for specific platform behaviors -- mobile browsers dismissing the keyboard before a tap's click lands, iOS refusing programmatic focus outside a gesture, WebKit leaving the layout viewport panned after the keyboard hides, overlay chains handing off through a frame where nothing is open. Verbatim moves: every timeout, flushSync and guard keeps its value and its reason, because none of them is verifiable outside a real device. * refactor(ui): extract outgoing message assembly A single send can carry queued messages, the composer text, inline review comments, resolved @file attachments, a linked issue or PR, synthetic parts from conflict resolution, and a skills instruction -- all flattened into OpenCode's one-primary-plus-parts shape. The flattening rules were spread through handleSubmit with no coverage, so the ordering they encode (oldest queued message becomes primary; inline comments attach to the last authored body, not a new part; PR instructions precede the diff) was trusted rather than checked. buildOutgoingMessage is a pure function over injected resolvers, with 25 tests covering that ordering. * refactor(ui): extract new-session draft targeting Move project and worktree selection for the new-session draft into composer/state/useDraftTarget. The rule worth naming is that the draft can point at a directory that does not exist yet -- a worktree still being created. It has to survive not appearing in the branch list, or the selector snaps back to the project root mid-creation and the session starts in the wrong place. * refactor(ui): extract composer context chips and linked reference rows The chips standing for attached-but-not-typed context (review comments, dev server logs, preview annotations, terminal selections) were four near-identical inline blocks; three of them collapse into one CountChip. The linked issue and linked PR rows were 100 lines of duplicated markup differing only in their number label, their branch line and which picker they reopen. They are now one LinkedReferenceRow. * refactor(ui): extract draft target selectors Move the project and branch pickers into composer/ui/DraftTargetSelectors: inline selects for desktop, trigger buttons and bottom sheets for mobile, all rendering the same options from useDraftTarget. The project label -- custom icon image, configured icon, or a folder fallback, with the project name -- was a useCallback rendering JSX and used from four places; it is now a ProjectLabel component. * refactor(ui): extract the collapsed mobile pill composer Move the pill into composer/ui/MobilePillComposer. Both places that ask dictation to start now go through one toggleDictation callback rather than dispatching the global event inline. * refactor(ui): extract the composer footer Move the footer row into composer/ui/ComposerFooter, which now owns the desktop and mobile layouts and the components they place. ChatInput keeps only the handlers it passes in. * refactor(ui): collapse the composer's four autocomplete states into one The composer tracked each picker with its own show flag and query string, which encoded 'exactly one is open' as four booleans that had to be kept mutually exclusive by hand. It is now one openAutocomplete kind plus one query, which is what resolveAutocompleteTrigger already returns. The four popup blocks -- identical apart from their component and caret width -- become ComposerAutocompletePopups. * refactor(ui): extract autocomplete positioning and message history useAutocompletePosition owns caret-relative popup placement, which only applies in focus mode. useMessageHistory owns arrow-key recall. Its transitions are pure functions with tests: entering history stashes the draft exactly once, so walking back several messages and returning still restores what the user actually typed rather than the last recalled message. * docs: document the composer module Record what each layer owns and the invariants that are not visible from the code: that the prompt language is the single source of truth for syntax, which ordering rules in the submit assembly and draft lifecycle are load-bearing, that the mobile hooks are platform corrections rather than state machines, and that rendering, focus, keyboard and WKWebView behavior are not covered by tests and must be verified by hand. * fix(ui): restore the composer caret colour and click-to-focus Two regressions from the editor migration. The caret rendered black in dark themes. CodeMirror's base theme hard-codes it through '.cm-editor.cm-light .cm-content', one class more specific than the plain '.cm-content' rule the composer theme used, so the base theme won. Matching that specificity with '&.cm-editor' fixes both variants. Clicking the composer's empty space no longer focused it. A textarea filled its box, so the browser placed the caret for any click inside it; CodeMirror's content element covers only the text. The content box now stretches to the full editor height, and clicks landing outside it — in the composer's padding — are forwarded to the nearest text position. The theme moves to its own module with a test that installs it. EditorView.theme compiles selectors at import and throws on scopes it was not given, including '&light' and '&dark'; neither the build nor the type-check catches that, and the failure takes the whole composer down at runtime. * fix(ui): colour the composer caret where it is actually drawn The previous fix styled caret-color, which drawSelection() overrides with 'transparent !important' at the highest precedence -- it hides the native caret and draws its own .cm-cursor element, whose base style is a hard-coded 'border-left: 1.2px solid black'. So the caret stayed black on dark themes. CodeMirror recolours that cursor only for editors that declare themselves dark. OpenChamber themes are not merely light or dark, so the cursor takes the surface foreground directly instead. The theme spec is exported and asserted against: the caret rule must target .cm-cursor, must not style caret-color, and must carry enough specificity to beat CodeMirror's own &dark override. * feat(ui): add emphasis, attention and path highlighting to the composer The constructs the editor migration was for. - **bold** and *italic* render as real weight and slant. They are additive styles: a segment carries one class string, so choosing between weight and colour would lose one of them -- bold inside a heading now keeps the heading colour and gains weight. - '!!! ' marks an attention line. Three marks, so a sentence ending in '!!' is not swallowed. - '~path' highlights a path without attaching it, unlike '@path'. Inert by design: it feeds neither the autocomplete nor the send path. False positives are excluded positionally rather than by character, since these delimiters are ordinary prose: '2 * 3' and 'foo_bar' are not emphasis, '~approximately' and '~1.2 seconds' are not paths. Also fix the expanded composer, which kept the collapsed composer's eight-line height cap: the editor scrolled inside an invisible window while the rest of the surface sat empty. * fix(ui): style the composer's selection instead of leaving CodeMirror's Selecting text rendered it in CodeMirror's stock lavender, which buried the token colours. drawSelection() paints its own layer and CodeMirror styles the focused case through a six-class selector; the composer's rule was three deep and lost. The tint is translucent rather than the flat selection token: an opaque selection hides the colours the composer exists to show, and selecting text here is for moving it, not for stopping reading it. Same failure shape as the caret, so the theme test now covers both. * fix(ui): mute the composer placeholder The placeholder rendered at full text brightness. Its colour referenced --surface-mutedForeground, but the theme emits --surface-muted-foreground: an unknown custom property makes the declaration invalid rather than falling back, and since color inherits, the placeholder simply took the editor's text colour while the source looked correct. The theme test now rejects camelCased tokens outright, since this failure is invisible in every check that does not render. * fix(ui): create the composer editor before the expand gesture ends The mobile pill expands with flushSync and focuses the editor on the very next line, still inside the tap's call stack, because that is the only way a mobile browser raises the keyboard. The EditorView was created in a passive effect, which flushSync makes no promise about — so at the moment focus() was called there was no view to focus. With a textarea the element existed as soon as flushSync returned, which is why this worked before the migration. Creating the view in a layout effect restores that ordering. * perf(ui): keep the composer editor alive across the mobile pill swap The pill and the full composer are different subtrees, so expanding or collapsing unmounted and rebuilt the editor. With a textarea that was one DOM node. A CodeMirror view is extensions, state, document, decorations and a first measure — all inside the tap's flushSync, before the browser is allowed to paint the swap. The shape change therefore landed late enough to look driven by the keyboard rather than by the tap. The view now lives in a store owned by ChatInput and is detached and re-attached instead of destroyed and rebuilt. Its extensions read callbacks through a ref held by the store, so a kept view always calls into the mounted instance; compartments move to module scope, since per-instance ones would be unknown to a reused view's configuration. Also restore the caret hold: WKWebView draws the caret as a native layer that ignores CSS transforms and visibly flies across the screen during the keyboard slide. The rule hiding it targeted textarea and input, which the composer is no longer — and its caret is now a drawn .cm-cursor element rather than the native one. * debug(ui): on-screen timeline for the mobile composer swap TEMPORARY, Capacitor-only. Two plausible fixes for the swap lagging behind the keyboard changed nothing, so the theory behind them was wrong. This overlay draws the event timeline straight onto the screen -- the tap, the committed swap, the first paints after it, the keyboard choreography, and whether the editor was created or re-attached -- so one screenshot replaces guessing. It doubles as an asset-freshness check: no overlay means the app runs a bundle from before this commit. * fix(ui): put the composer swap on glass before the keyboard moves The overlay timelines settled it. The swap itself was never slow: commit in 12ms, editor re-attach in 3ms, focus immediate. What lagged was presentation: WKWebView stops presenting web frames the moment focus starts the keyboard transition and holds the last presented frame until it ends. Focusing in the same task as the swap meant the last presented frame still showed the pill — paint-1 fired at 29ms, the next frame at 190ms, exactly when the keyboard was already moving. On expand, Capacitor now waits two frames before focusing, so the swapped composer is presented first and the keyboard rises under it. The Capacitor WebView raises the keyboard for a focus() outside the gesture task; mobile browsers do not, so they keep the synchronous path. The collapse direction had a genuine race, caught on one screenshot: the oc:keyboard-intent collapse arrives a few milliseconds after blur on a setTimeout(0), and React's scheduling of setFocused(false) can lose to it — busyRef stays stale, the intent handler skips the instant collapse, and the pill appears via the 250ms fallback, 370ms after the keyboard has gone. The Capacitor blur branch now commits the state with flushSync. The diagnostic overlay stays in until this is confirmed on device. * fix(ui): raise the keyboard from the swap's first frame Two frames of delay before focusing made expand visibly sequential: swap, then keyboard. Focusing inside the first frame after the commit puts the swap's frame into the rendering pipeline before the keyboard transaction starts, so the keyboard rises from the tap and the composer appears during the rise rather than after it. * fix(ui): restructure the draft screen in the same frame as the pill swap The draft screen centers its title over the space the composer leaves, and its starter chips leave when the keyboard is up. The chips were keyed on oc-keyboard-open, which lands with the keyboardWillShow bridge event ~100ms after the tap — so expanding the composer restructured the page twice: once at the swap (composer grows, title re-centers) and again mid-keyboard-rise (chips vanish, title re-centers again). Chat has no centered content, which is why it was already smooth and the draft screen was not. A root class now announces the expanded composer from a layout effect, in the same frame as the swap, and the chips key on it: one restructure, fused with the pill morph, before the keyboard moves. The keyboard classes remain as fallbacks for keyboard-up states that do not go through the pill. * debug(ui): remove the mobile swap timeline overlay The diagnostic did its job: it identified WKWebView's presentation pause during keyboard transitions, the React-scheduling race in the collapse path, and the draft screen's double restructure — all fixed and confirmed on device. * feat(ui): grow the mobile composer with content, drop the fullscreen handle The swipe-up handle promised a fullscreen composer but the normal eight-line cap already reached within a line of the same height, so the gesture bought almost nothing and cost a 28px bar above the editor. The composer now just grows with what is typed: a generous line cap plus a CSS ceiling of the space the keyboard actually leaves, whichever is smaller (the editor cap accepts both and takes min()). The handle, its swipe gestures and the shell's touch plumbing are gone. * fix(ui): measure the mobile composer ceiling instead of estimating it The 220px chrome constant guessed at what surrounds the editor. The old fullscreen handle guessed at nothing — it let flex distribute real space (and on Capacitor even that silently failed: its h-full resolved against a shrink-wrap parent, which is why the gesture bought almost nothing). The ceiling is now measured the way the handle meant to: the screen container is marked data-composer-bound, and the editor may grow until the composer fills it — chrome around the editor read live from the DOM, so attachment chips, the model row and keyboard resizes all shift the cap by themselves. * fix(ui): keep a 4px gap between the grown composer and the header On the chat screen the fully grown composer's border landed exactly on the header's bottom edge. The gap is a visual design choice, not another chrome estimate: the ceiling itself stays measured. * fix(ui): show iOS selection handles without giving up typing speed iOS pins its selection drag handles to the visible native selection and colours them from the caret, while drawSelection() hides both. Removing drawSelection(), or leaving the native caret visible while typing, both make iOS answer every keystroke with severe input lag. Touch devices now keep drawSelection() and layer a theme over it that re-shows the native selection, plus an .oc-native-range marker that enables the native caret only while a range is selected — when there is no caret to lag on. * feat(ui): make file mentions editable instead of atomic-delete Deleting a character inside an @file mention edited nothing and erased the whole token. Mentions now edit like /skill tokens: a deletion changes the text and the caret position reopens the file picker on its own. findMentionAt and MentionToken.rawEnd existed only for the atomic delete and are removed. * fix(ui): composer selection visibility and external-insert caret Selection was nearly invisible for two reasons: the tint was mixed down from --interactive-selection, which themes define with its own alpha (often under 10%); and the painted selection layer sits behind the content, so tokens with their own background (inline code, fences) covered it entirely. The native selection now shows on every device, not only touch — it paints over token backgrounds — and its tint comes from --primary at 25%, a full-strength colour in every theme. drawSelection() and the range-scoped native caret stay exactly as before, so typing keeps the lag-free path. External rewrites (add-to-chat, draft restore, history, dictation) also left the caret at its old position, so the next insertion landed inside the previous one. They now put the caret at the end, as the old textarea did, and pin the scroller to the bottom once the layout settles — a transaction-time scrollIntoView fires before the max-height cap exists and scrolls nothing. * fix(ui): render ***triple emphasis*** as bold italic The emphasis tokenizer capped delimiter runs at two characters, so ***x*** parsed as a stray asterisk plus an italic span. Runs of three now emit both a strong and an emphasis range over the same content; the two are additive styles, so they compose into bold italic. * fix: insert mentions through editor dispatch Places the caret immediately after an inserted mention Avoids rewriting the whole message and jumping the scroll to the bottom Falls back to appending inline text when no editor is available	2026-07-27 22:21:38 +03:00
Bohdan Triapitsyn	e908db637b	feat: agent and CLI control plane for sessions, worktrees, and scheduled tasks (#2408) ... Add a shared OpenChamber control service with two thin adapters — a native `openchamber` tool injected into managed OpenCode, and new CLI commands — so users can manage parallel sessions, worktrees, and scheduled tasks conversationally through agents or from the terminal. Control plane: - New openchamber-control service owning a fixed action contract: projects.list, models.list, session list/create/send/fork/status/messages, and schedule list/create/run/delete/toggle. Session and worktree deletion and project registration are deliberately not exposed. - New openchamber-sessions module owning create/worktree/prompt orchestration, Goal Mode dispatch, wait semantics (initial idle never counts as completion; timeout and cancellation are failures), and explicit partial-failure results. - Scheduled-task logic extracted into a service shared by routes, CLI, and the agent tool. Agent tool: - Managed OpenCode gets a materialized plugin registering one typed tool with a loopback-only callback, per-child ephemeral bearer (timing-safe, never persisted or logged), and abort propagation into the service. - The ~1.5k-token schema applies progressive disclosure: short descriptions, server-side validation returning actionable usage errors, and intent guardrails — created sessions/tasks are user-facing work (not age self-delegation); worktree/goal/agent/variant/wait are omit-by-default; dispatches produce no completion notification, and later result r to session.messages, which now returns the authoritative sessionStatus. - session.create without a user-named model picks from favorites/re send/fork omit the selection and the service reuses the target session's last user-message model, agent, and variant before falling back t - An "Agent control tool" setting (default on, Save + Reload to apply) disables plugin injection entirely. CLI: - New `openchamber session`, `schedule`, `projects`, and `models` commands with automatic instance targeting, --wait/--timeout/--last-assist worktree flags, and Goal Mode, preserving interactive, non-TTY, --quiet, and --json contracts. The control HTTP timeout derives from the w instead of the 4-second default. UI: - New built-in "Schedule a Task" starter (/schedule-task) running a dialogue that defines a task and offers to create it via the tool after explicit confirmation; Craft a Goal and Feature Planning gain the handoff offer, and guided starters reserve the question tool for concrete option choices. Localized in all 10 locales, migrated into custom starter lists, hidden on VS Code. - Sidebar shows CLI/agent-created sessions live via the control eve - openchamber tool calls render with per-action titles and metadata.	2026-07-24 21:54:28 +03:00
Bohdan Triapitsyn	d654911925	feat: warn about unsupported attachment inputs ... Compare normalized attachment MIME types with the selected model's declared input modalities and show a non-blocking warning for incompatible files. Recheck newly added attachments, restored drafts, async metadata, and existing files after model changes while avoiding warnings when capability metadata is unavailable. Summarize affected filenames and localize the warning across every supported locale. Add focused modality compatibility coverage, document the composer behavior, and keep model metadata subscriptions stable to prevent startup render loops.	2026-07-22 14:40:40 +03:00
Bohdan Triapitsyn	a68443c559	feat: expand chat attachment processing ... Add picker and MIME support for more source-code, diff, notebook, structured-log, SVG, and Draw.io formats. Convert Jupyter notebooks into readable text while omitting binary outputs, and sanitize HAR credentials, cookies, sensitive query parameters, and request/response bodies before files enter chat state. Convert HEIC and HEIF images to JPEG up front, centralize attachment preparation in a focused module, and cover the new validation and transformation behavior with regression tests.	2026-07-22 11:54:03 +03:00
Bohdan Triapitsyn	d3a2564cf6	feat: normalize and filter chat attachments ... Attachment pickers now share an allowlist for supported file types Local attachments are normalized to consistent MIME types before upload VS Code file picker now respects extension filters and larger files are allowed	2026-07-22 11:33:22 +03:00
Bohdan Triapitsyn	85400459e9	perf: overhaul session loading, caching, and runtime isolation (#2360) ... Improve OpenChamber responsiveness under large session workloads while fixing cache, synchronization, and persistence correctness across runtimes, projects, directories, and worktrees. - prioritize selected and visible sessions during bootstrap and defer non-critical enrichment work - reduce redundant message loading, event processing, store publication, and hidden sidebar work - prevent stale session and message requests from overwriting newer authoritative state - preserve existing data when authoritative fetches fail instead of treating failures as successful empty responses - scope session materialization, messages, drafts, queues, todos, pins, permissions, folders, tabs, Git state, and pull request data by runtime and directory identity - harden runtime switching, reconnect, cleanup, mutation reconciliation, and persisted-state ordering - preserve live subagent Task linkage when metadata arrives after an older message request or while streaming parts are suspended - coalesce overlapping tail refreshes without losing newer refresh demand - improve cold-session loading by moving deferrable work out of the critical bootstrap path - isolate URL authentication, mobile credentials, native secrets, and other runtime-owned state across endpoint changes - bound long-lived caches and remove avoidable allocations from event and rendering hot paths - limit virtualization to archive collections where it improves rendering without disrupting active sidebar layout - stabilize session folders, pin ordering, expanded state, and persisted sidebar behavior - open skill files through the same secure editor and outside-workspace grant flow used by file navigation, including worktree sessions - expand regression coverage for stale completions, runtime collisions, reconnect behavior, persistence races, authoritative empty results, and subagent refresh ordering - document the updated synchronization, cache ownership, performance, and runtime-isolation invariants	2026-07-21 20:52:20 +03:00
Bohdan Triapitsyn	9c226a5bd4	fix: preserve chat input button overflow during draft toggle ... Keeps the button visible state aligned with the draft panel animation Moves overflow handling to the collapsed state only	2026-07-18 09:31:15 +03:00
Bohdan Triapitsyn	72a60f93fd	fix: add shadow to chat input elements on mobile for visual consistency ... Fix alignment of settings radio options when no description is present	2026-07-18 00:56:32 +03:00
Bohdan Triapitsyn	2af5cd39d1	feat: add subtle shadows to chat input and sidebar ... Added a box shadow to the chat input on desktop for depth Added an inset shadow to the sidebar when open for visual separation	2026-07-18 00:18:28 +03:00
Bohdan Triapitsyn	d4a8c4d2e1	feat(terminal): refactor runtime and add mobile workspace (#2280) ... Replace the legacy terminal flow with a shared authenticated WebSocket runtime used across web, desktop, relay, and mobile surfaces. - introduce the v3 terminal protocol with scoped attachments, snapshots, ordered output, bounded replay history, reconnects, and explicit lifecycle - harden PTY creation, restart, resize, close, force-kill, idle cleanup, shell selection, login mode, environment sanitization, and appearance sync - add runtime-aware terminal APIs with relay authentication and Electron parity - add a fullscreen mobile terminal workspace with touch scrolling, long-press selection, safe-area controls, quick keys, and Ctrl/Alt input - add terminal selection attachments, preview detection, project actions, shell settings, and localized UI - harden Ghostty rendering, resize recovery, Unicode handling, block characters, line height, and stale-row behavior - remove the obsolete terminal SSE path and update reverse-proxy guidance - expand terminal runtime, transport, input, selection, and store coverage - avoid duplicate web builds when preparing mobile assets in root CI builds	2026-07-17 13:17:21 +03:00
Bohdan Triapitsyn	95e3e1cf2e	fix(chat): preserve prompt when session creation fails ... Keep the new-session draft open until the backend confirms that the session was created successfully. This prevents a failed request from closing the draft and discarding the user's creation context. Restore the exact submitted composer text after a new-session send failure and persist it as the draft. Only restore when the composer is still empty or unchanged, so text entered while the request is pending is not overwritten. Add regression coverage that simulates an offline session creation request and verifies that the draft remains open with its title intact.	2026-07-17 10:31:56 +03:00
Bohdan Triapitsyn	4eac90ad44	fix(chat): decouple input from editor font size ... The editor font size setting controls code editors and should not also resize the chat composer. Code and conversational input have different readability and layout requirements, so forcing them to share one size is not appropriate.	2026-07-14 14:45:49 +03:00
Leonidandbashrusakh	e1fc3882e3	fix(chat): restore editor font size styling in chat input (#2199) ... Commit 5c6546245 removed the editorFontSize reading and inline font-size styling from ChatInput, calling it 'unused'. However this code was the core of the editor font size feature (feat/e0229917f) — it applies the user's chosen font size to the chat input textarea. Without it, changing Settings > Appearance > Editor font size has no effect on the chat input textarea. The CodeMirror editor (FilesView, PlanView) was unaffected because its font size path was not touched. This reverts the ChatInput portion of 5c6546245, restoring: - useUIStore selector for editorFontSize - inline fontSize style on the textarea element Co-authored-by: bashrusakh <bashrusakh@users.noreply.github.com>	2026-07-14 14:27:48 +03:00
Bohdan Triapitsyn	a0bdcae54c	feat: add craft-goal session starter and command ... Adds /craft-goal autocomplete and chat handling for starting a Goal crafting session. Introduces new Magic Prompts content and localized labels/descriptions for Goal crafting. Migrates desktop draft starters to include Craft a Goal once and persists the migration marker.	2026-07-12 10:58:58 +03:00
Bohdan Triapitsyn	bb45164ae8	feat: session goals - server-driven goal loop with independent small-model audit (#2148) ... Arm the target button in the composer and the next prompt becomes a goal: the server keeps the session working toward it (idle tick -> small-model audit -> continuation) until the objective is verifiably complete, blocked, or out of budget — even with the UI closed. Server (packages/web/server/lib/session-goal): - event-driven loop on the global SSE hub; goal state lives in session.metadata.openchamber.goal (merge-safe patches, stale-write guard by goal id), so it survives restarts and syncs to every client for free - the small-model audit (objective + last assistant turn only, language pinned to the objective) is the sole termination authority; blocked needs 3 consecutive verdicts, audit outages tolerate one unaudited continuation then stop the goal as resumable-blocked - hard stops: optional token budget, auto-continuation cap (Resume grants a fresh allowance), turn errors; user abort pauses the goal instead of blocking it, and resuming over an aborted tail nudges immediately - token accounting as a snapshot of the latest turn (input + cache.read + output), goal-relative via a creation baseline and segmented across compactions; a compaction summary skips the audit and continues - continuations reuse the session's own provider/model/agent/variant UI: - three-mode target button (arm / disarm / manage dialog), informational goal strip with inline pause/resume and an Evaluating indicator, sidebar state glyph, objective length counter (2000-char server clamp), read-only completed goals - goal entry points: composer (sessions and drafts), start-new-session- from-answer dialog, plan implement dialog (plan content becomes the objective), scheduled tasks (Run as goal + budget) - Settings -> Chat -> Goal: feature toggle + default token budget with three-layer parity (web server, client persistence, VS Code bridge); VS Code renders goal state but hides the entry points (the loop runs in the web server only) Notifications: per-turn "ready" notifications are suppressed while a goal is active; settling sends one final notification (desktop, web-push, APNs generic titles with the session name as body) honoring the completion toggle. Error/question/permission notifications are untouched. Docs: user guide (session-goals) in all 9 locales + sidebar entry, scheduled-tasks cross-reference, server module DOCUMENTATION.md.	2026-07-12 01:23:22 +03:00
Bohdan Triapitsyn	5c65462454	refactor: remove unused editor font size styling from chat input ... Stops reading editor font size from UI state in ChatInput Removes inline font-size styling from the text area	2026-07-11 18:17:21 +03:00
Leonidandbashrusakh	9bfc5bf0be	fix(chat): enable draft auto-accept before first message (#2045) ... * fix(chat): enable draft auto-accept before first message * fix(test): use supported bun assertions * fix(chat): apply draft auto-accept before session switch --------- Co-authored-by: bashrusakh <bashrusakh@users.noreply.github.com>	2026-07-11 15:15:02 +03:00
3 people	e0229917f8	feat(settings): editor font size for chat input and code editor (#1325) (#2065) ... * feat(settings): add editor font size setting for chat input and code editor Adds an 'Editor font size' control in Settings > Appearance that sets an absolute px font size for the chat input textarea and the in-app CodeMirror editor. Mirrors the existing terminalFontSize lifecycle. - New store field editorFontSize (default 13, clamp 9-32, step 1) in useUIStore with narrow selectors at each consumer. - Persistence wired through appearanceAutoSave, desktop + runtime API types, and persistence.ts read/normalize. - Settings UI row (NumberInput) with reset to 13, VisibleSetting union entry, OpenChamberPage registration, and search index entry appearance.editor-font-size. - Applied as a post-zoom absolute override on the chat input textarea and on the CodeMirror theme's content rule, leaving gutter/line-number chrome at its existing hardcoded sizes (matches terminal scope). - All 10 locales translated (en, es, fr, ja, ko, pl, pt-BR, uk, zh-CN, zh-TW); no English placeholders in non-English dictionaries. Refs #1325 * fix(codemirror): use unitless lineHeight so it scales with editor font size The & rule in the CodeMirror theme set lineHeight to 1.5rem (~24px), which does not scale when editorFontSize is increased (e.g., 28-32px). This causes overlapping lines at larger font sizes. Change to unitless 1.5, which scales proportionally with whatever fontSize resolves to (dynamic prop or --text-code fallback). Matches browser best practice for proportional leading. Review comment: https://github.com/openchamber/openchamber/pull/2065 --------- Co-authored-by: bashrusakh <bashrusakh@users.noreply.github.com> Co-authored-by: Bohdan Triapitsyn <artmore@protonmail.com>	2026-07-11 14:45:27 +03:00
Bohdan Triapitsyn	ac93a52e21	feat: iPad split layout for the Capacitor app (#2104) ... * fix: open mobile model/agent panels on tablet-width Capacitor shells and keep composer taps from dismissing the keyboard * feat: add iPadOS-style split layout to the Capacitor app - classify the Capacitor shell as mobile in device detection so shared surfaces (draft starters, panels) stop falling into tablet branches - add isIPadApp() and useOrientation() helpers - iPad: persistent full-height sessions sidebar (mobile sessions surface inline), Changes/Files in a right sidebar with header shortcut toggles - animate sidebar open/close like the desktop sidebars and add finger-sized drag-resize with persisted widths - anchor the overflow menu and the usage/metadata popover next to their header buttons regardless of open sidebars * fix: re-anchor metadata popover on layout shifts and untangle sidebar toggle updates - recompute the iPad metadata popover anchor via a ResizeObserver on its wrapper so sidebar toggles/resizes while it is open cannot leave it misplaced - move the portrait right-panel close out of the setIpadSidebarOpen updater into plain sequential state updates	2026-07-08 21:52:18 +03:00
Bohdan Triapitsyn	5101fab962	fix: keep local file picker mounted during composer swaps ... Moves the hidden file input out of the attachment controls so it stays mounted. Prevents file selections from being lost when the composer variant changes. Restores reliable local attachment uploads after opening the OS picker.	2026-07-07 10:32:13 +03:00
Bohdan Triapitsyn	9ceb027e75	fix: preserve composer taps while the keyboard dismisses ... Keeps mobile composer controls from missing taps during keyboard blur/reflow Applies the deferred blur behavior to mobile browsers and installed PWAs Leaves Capacitor behavior unchanged	2026-07-07 10:20:14 +03:00
Bohdan Triapitsyn	856b312da1	fix: grow composer with dictation transcript like typed text ... The dictation overlay is absolutely positioned over the composer, so the transcript could not expand it — long dictations clipped after two lines. ComposerDictation now measures the transcript text block (not the flex-1 container, which would feed the composer's own height back and creep a few px per update) and reports it to ChatInput, which feeds it into the textarea autosize: same line cap as typing, transcript area scrolls past it and follows the newest words. Idle/unmount releases the height, and an idle sibling instance (mobile footer + wrapper engine) can no longer zero the active one's report.	2026-07-07 01:40:00 +03:00
Bohdan Triapitsyn	24c40b4930	fix: iOS PWA safe areas, viewport stability, and keyboard/overlay choreography ... - Add standalone-only safe-area padding for the composer (bottom floor + fullscreen top inset) and top toast offset; env() reports 0 on iOS 26 standalone so a fixed floor is required - Pin the mobile shell to 100lvh: WebKit leaves 100dvh stuck at the keyboard-shrunk value after dismissal - Clamp visual-viewport pinning to documentElement.clientHeight to guard against stale visualViewport metrics - Defer the composer blur flip (120ms) so taps on composer controls survive the keyboard-resize reflow; transition the bottom padding so the late flip reads as a slide, not a dip - Restore the keyboard after mobile overlays close: MobileOverlayPanel dispatches synchronous open/close events, ChatInput refocuses within the same gesture, holds focus through iOS's tap-settle dismissal, guards the pill collapse via DOM focus, and reveals the composer form above the keyboard (programmatic focus skips iOS's native reveal)	2026-07-07 01:25:28 +03:00
Bohdan Triapitsyn	1824b51155	fix: scope session assist to session directory	2026-07-06 20:00:53 +03:00
Bohdan Triapitsyn	81c9e6eaa2	fix: preserve chat composer focus on mobile keyboard ... Keeps the textarea reference available during mobile viewport adjustments Ensures the composer scrolls back into view after keyboard interactions Updates text selection menu dependencies to include the current session	2026-07-06 00:39:49 +03:00
Bohdan Triapitsyn	28f0736d69	feat: small-model utility calls on existing OpenCode providers (#2049) ... Adds a server-side "small model" capability: direct, cheap LLM calls that reuse the user's existing OpenCode provider logins — the mechanism OpenCode uses internally for titles and summaries but does not expose through the SDK or plugins. Zero new dependencies; plain fetch with per-provider wire formats, credentials never leave the server. Core (packages/web/server/lib/small-model): - Resolution mirrors OpenCode's session scoping: explicit settings override → small_model from the OpenCode config → family scan within the session's provider → the session's own model. The global provider scan only serves callers without a session context, and background callers forbid it entirely (restrictToPreferredProvider), so conversation content never reaches a provider the user didn't pick — explicit choices excepted. - Per-provider auth replicating OpenCode's plugin loaders: GitHub Copilot (device token as bearer, no exchange), ChatGPT plan via the codex Responses API (single-flight OAuth refresh written back to auth.json), Anthropic messages, Google generateContent, generic OpenAI-compatible. - OpenCode's free models (opencode/big-pickle, *-free) are never called directly; unauthenticated providers are skipped by design. - Prompt clamping to the model's catalog context limit; thinking disabled where a wire switch exists (Z.AI/GLM, MiniMax-M3, Gemini Flash); robust content parsing with a clear error when a thinking model spends its whol budget on reasoning. - Settings → Sessions gains a Small Model group: use-default checkbox plus an override picker limited to authenticated providers, persisted with web/desktop/VS Code sanitization parity. Consumers: - Session assist: a server-side watcher on the global SSE hub generates a short recap and one suggested follow-up after a session idles quietly fo a minute, stored on session metadata (openchamber.assist). Freshness is keyed to the last assistant message id, so new activity invalidates the payload everywhere with no extra writes. The chat shows the recap under the last message after five quiet minutes and the suggestion as a dismissible chip above the composer (tap fills the input, never sends). Gated by a new Chat setting (default on) that is a hard generation switch. Language is anchored to the conversation itself, with a script-mismatch guard against model/backend language hallucination. - TTS: a third input mode, summarized — long replies are condensed to spoken prose before playback on any TTS engine. - Git: commit-message and PR generation moved off the active chat session onto the small model fed with real diffs and the commit list (bodies included), with a session-transport fallback for free-model-only setups. - Notes: Add to notes distills long selections into 1-3 dense sentences preserving exact identifiers, with verbatim fallback on failure. Fixes along the way: - The global event watcher now starts unconditionally; it was gated behind the desktop-notify env, leaving the server-side event hub dead in packaged apps. - OpenCode re-emits message.updated for old user messages after idle; the watcher no longer mistakes those for new activity. - Session metadata merges from a fresh read right before the PATCH, so writes made during the generation window (suggestion dismissals, review links) are preserved; the assist runtime stops during graceful shutdown.	2026-07-05 23:19:10 +03:00
Bohdan Triapitsyn	b09e073e86	fix(mobile): browser composer keyboard handling on chat and draft screens ... Mobile browsers don't shrink the layout for the keyboard, so the fullscreen composer is now pinned to the visual viewport (fixed at its offset and height, tracked as the browser pans) instead of overflowing underneath it; the draft screen's normal composer gets the same pinning anchored to the visible bottom via a rAF tracker, since Safari's own focused-field reveal proved unreliable there after leaving fullscreen. The draft and empty-session roots drop their transform-gpu (a transform would make them the containing block for the pinned form), the app header hides while the browser fullscreen composer is up (the form can't out-stack it from inside the composer wrapper's stacking context), and leaving fullscreen nudges the still-focused field back into view. Draft starter chips now hide while the keyboard is open in browsers too, via an oc-browser-keyboard-open root class driven by composer focus.	2026-07-05 09:14:55 +03:00
Bohdan Triapitsyn	d762b69cec	feat(mobile): autocomplete redesign for touch surfaces ... Command, file/agent, skill, and snippet autocompletes now stop at the top of the chat area (Capacitor) or the visible viewport edge (mobile browsers, which pan the page for the keyboard) and may grow that far, measured live across keyboard settles and viewport changes. On mobile the keyboard-hint footer and description lines are gone, rows center their icons, and list overscroll no longer bounces the page behind. Selecting a command no longer dismisses the keyboard (its rows now block the tap's focus steal like the composer buttons), and the dead dismissKeyboard option is removed.	2026-07-05 02:58:41 +03:00
Bohdan Triapitsyn	da78de3a21	fix(chat): send preset starters directly instead of staging them in the composer ... Starter chips route their text into the submit as an explicit override; the previous flow staged it in the textarea, which doesn't exist while the mobile composer is collapsed into the pill, so the submit read an empty snapshot and silently bailed, leaving the command text sitting in the input.	2026-07-05 02:32:40 +03:00
Bohdan Triapitsyn	0645cebe02	fix(mobile): open the keyboard from the pill in browsers and draft unreleased changelog ... The pill's expand focused the textarea from a rAF, outside the user gesture — mobile browsers only show the soft keyboard for synchronous focus, so the composer expanded silently. The expand now flushes the render and focuses in the same gesture, and preventScroll applies only inside the Capacitor shell so browsers keep their native reveal that lifts the field above the keyboard (same for the post-overlay keyboard restore). Also drafts the [Unreleased] changelog entries for everything since v1.13.9.	2026-07-05 02:11:45 +03:00
Bohdan Triapitsyn	dbcb655e43	feat(mobile): synchronized pill composer transitions and draft screen fixes ... Drop the animated pill/composer morph in favor of instant swaps that are synchronized with the keyboard choreography: a new oc:keyboard-intent event collapses the composer (flushSync) before the hide compensation is measured, so keyboard travel and composer height change land as a single chat motion on both iOS and Android (Android also gains keyboard signals and deterministic re-pins around its native resize). The WKWebView caret is hidden during the transition so it no longer flies to its new position. Draft screen: starter chips hide instantly while the keyboard is up and the centered title rides the keyboard shift compensation instead of double-jumping; the composer drag handle also works in dictation mode; the highlight mirror is disabled on mobile so the caret matches the text. Fixes: worktree discovery and the GitHub auth probe now wait for the runtime connection (no more empty branch pickers / stale auth on cold start), worktree discovery merges per project instead of clobbering the persisted map, the cross-project session list resets on instance switch (with an in-flight load guard) so no stale sessions linger, and mobile overlay content contains its overscroll instead of bouncing the page.	2026-07-05 00:05:38 +03:00
Bohdan Triapitsyn	fb839b66a9	feat(mobile): collapsed pill composer and mobile input redesign ... Mobile composer redesign: when the keyboard is closed the input collapses into a narrow pill (sessions, attach, placeholder, mic) with a round new-session button that fades away on the draft screen. Model and agent selectors move into a row above the textarea; the draft project/branch pickers and the attachment menu become searchable bottom sheets reusing MobileOverlayPanel; a drag handle (also available while dictating) swipes the composer into and out of a fullscreen mode. Keyboard-lifecycle hardening: composer controls (agent cycle, dictation and its overlay controls) no longer steal focus and dismiss the keyboard; overlays reopen the keyboard on close via a debounced restore chain that survives menu-to-picker handoffs and skips the native file picker; open overlays and dictation keep the composer expanded. Dictation starts directly from the pill and its overlay content fades in after the shape settles. The keyboard slide compensates the pill-to-full height change in one motion, and the mobile highlight mirror is disabled so the caret always matches the text layout.	2026-07-04 16:41:17 +03:00
Bohdan Triapitsyn	de1b85ac56	feat(voice): first-class voice input and local TTS across web, desktop, and mobile (#2018) ... Complete rebuild of voice input on a server-authoritative streaming architecture, replacing the legacy Web Speech / whole-blob / WASM engines and the dead voice-agent layer (~4k lines removed). Speech-to-text (dictation): - Client streams 16 kHz mono PCM16 chunks over /api/dictation/ws with seq/ack ordering; buffered audio is retained and replayed on reconnect - Server transcribes and streams live partial transcripts back; segments auto-commit every ~15s with silence suppression and adaptive finalization timeouts - Local provider (default, zero config): sherpa-onnx models in a forked worker process — auto-download with progress, staged extraction with verification, corrupt-model auto-recovery, idle shutdown after 5 min - Model catalog with settings picker (accuracy/speed ratings, sizes, download/delete): Parakeet TDT v2 (English) and v3 (25 European languages, auto-detected), Whisper base and tiny (multilingual, light) - OpenAI-compatible provider for any Whisper endpoint - Composer overlay with live transcript, volume meter, timer, and cancel / insert / insert-and-send actions; failed transcriptions keep their audio for retry or accepting the partial text as-is - Configurable keyboard shortcut (default mod+alt+v) toggles dictation; Enter confirms and Escape cancels while recording - Overlay is pixel-aligned with the composer (measured footer height, matching paddings/typography/gaps) — no layout shift when toggling Text-to-speech: - Local Kokoro provider (English, 11 voices) synthesized in the same worker via /api/dictation/tts/speak, managed by the shared model pipeline; sentence-pipelined playback keeps time-to-first-audio at ~1 sentence regardless of message length, and stop cancels in-flight synthesis - Sanitizer keeps inline-code content (strips backticks only), reads interword slashes aloud, and removes only absolute file paths Settings: - Voice page unified: a single read-aloud toggle owns all playback options (the confusing "Enable Voice Mode" is gone); a new "Enable voice input" toggle (default on, persisted to settings.json) hides the composer mic entirely when disabled Mobile and transport: - iOS/Android microphone permissions added (dictation was previously impossible on mobile) - Fixed Android WebSocket upgrades: the Capacitor WebView origin (https://localhost) was missing from the packaged-client allowlist, 403-ing every WS connection — root cause of the old mobile SSE lock, which is now removed for all transports Security and conventions: - All HTTP routes sit behind the global /api auth gate; the WS upgrade explicitly validates the UI session and origin, with oc_url_token narrowly allowlisted and covered by tests; the dictation socket mints a fresh URL token before connecting - Routes register before the generic OpenCode proxy; the client goes through runtimeFetch/getRuntimeUrlResolver, and runtime switches reset the dictation socket - VS Code deliberately reports dictation as unavailable (no server process in that runtime) CI: workflow Node bumped 20 -> 22 to match the repo engines and fix better-sqlite3 installs broken by node-gyp@latest on Node 20. New dependency: sherpa-onnx-node (prebuilt N-API; macOS/Linux x64+arm64, Windows x64 — Windows-on-ARM falls back to the OpenAI-compatible provider)	2026-07-04 02:48:07 +03:00
Bohdan Triapitsyn	61a4a23add	feat: native iOS & Android mobile apps (Capacitor) (#1954) ... * feat(mobile): add Capacitor native shell * docs: add serve-sim workflow guidance * docs(mobile): add implementation handoff * chore(mobile): clean up generated defaults * feat(mobile): add connection onboarding * feat(mobile): manage saved instances * feat(mobile): refine connection management UI * chore(mobile): upgrade Capacitor 8 * fix(mobile): reliable saved-instance auth with secure token storage - store client tokens in the OS secure store (iOS Keychain / Android Keystore) per instance URL via direct native plugin calls; keep only token-less metadata in localStorage. Bound every secure call so a stalled bridge can't hang unlock. - bypass the secure-storage JS wrapper's lazy platform load (which stalled in the webview) by calling internalSetItem/internalGetItem/internalRemoveItem directly. - harden the shared connect/unlock controller (health + session + progressive password) and drop the heavy pre-connect hydration that stalled no-token hosts. - await token persistence before switching runtime endpoints (no fire-and-forget). - sync native iOS/Android projects + Keyboard/StatusBar config for Capacitor 8. * fix(mobile): keep UI stable across connection churn (no transport hardcoding) The "reload every ~10s" was a UX bug, not a transport one: - MobileSurfaceShell received a fresh inline onClose each parent render, so any re-render (e.g. an SSE/WS event) re-ran the focus effect and refocused the first element — stealing focus from the active input and collapsing the keyboard mid-edit. onClose now lives in a ref so the focus/keydown effect depends only on `open`. Fixes all sheets (Instances/Files/Changes/Settings). - Gate the mobile shell on connectionPhase, not the live isConnected flag, so a transient reconnect keeps MobileShell mounted instead of flashing the loader. - Instances form: populate fields imperatively on edit/cancel/save instead of via an effect keyed on the derived connection, so list churn can't wipe input. Transport stays on `auto` (WS-first with SSE fallback) — no hardcoded override, so WS-only Quick Tunnels and SSE-capable proxies both keep working. * feat(mobile): add native QR pairing-code scanner Wire the connection onboarding + Instances scan buttons to a real native scanner via @capacitor-mlkit/barcode-scanning, which registers as the BarcodeScanner plugin the existing mobileQrScan helper already resolves at runtime. Add NSCameraUsageDescription and bump the iOS deployment target to 15.5 (GoogleMLKit 8 requirement). * fix(cli): repair connect-url host resolution Define the missing isWildcardBindHost helper that connect-url called but was never declared, which crashed any link generation that reached host resolution. Also treat a full http(s) --host value as a public server URL so '--host https://example.com' produces a correct link instead of 'http://https://example.com:port'. * fix(mobile): make input follow the keyboard across all surfaces Switch the native Capacitor Keyboard plugin to resize: 'none' and drive the layout from an --oc-keyboard-inset CSS variable set on keyboardWillShow, which fires at the start of the iOS keyboard animation. A transition tuned to the native keyboard curve/duration (0.25s, cubic-bezier(0.38, 0.7, 0.125, 1)) makes the layout rise together with the keyboard instead of snapping into place after the built-in 'native' resize finished (~1.5s lag). The inset is consumed by every surface that can hold a focused input: - chat shell shrinks its height; - portal sheets/overlays raise their bottom edge; - the full-screen connect/login view caps its height so it actually scrolls (and is now generally scrollable for long saved-connection lists). * feat(mobile): rounder chat composer + native bottom safe area Round the mobile chat composer corners a touch more (1rem), and reserve a small app-level bottom safe area for the native shell via the --oc-app-bottom-safe token so controls clear the phone's rounded hardware corners. The reservation folds into the keyboard inset (no gap above the keyboard), and the composer's own bottom padding tightens while the keyboard is open. * fix(mobile): remove iOS 26 dark status-bar band; polish composer The dark band behind the status bar in system Dark Mode was iOS 26's automatic scroll edge effect (Liquid Glass) dimming the WebView's top edge beneath the status bar — appearance-coloured, so it tracked the system theme regardless of the in-app theme. Hide it via UIScrollView.topEdgeEffect/bottomEdgeEffect on the WebView's scroll view (iOS 26+), and make the WebView non-opaque so the themed web background shows under the overlaid status bar. Also: re-assert the status-bar overlay on resume, paint the document canvas with the theme background in the native shell, round the composer corners to 1.5rem, and enlarge the app-level bottom safe area so controls clear the rounded corners. * feat(mobile): logo splash until first paint is final (no FOUT / layout shift) Cold start flashed the fallback font and then reflowed once the real font and persisted appearance prefs landed, and text jumped a frame after mount because the mobile typography classes were applied from a hook effect. Fix it on three fronts: - apply device classes (device-mobile / mobile-pointer) synchronously in renderMobileApp before the first React paint, so mobile --text-* sizes are in effect from the start; - hold a logo splash (useFontsReady) until the UI web font has loaded; - gate that splash on appBootReady too, resolved once async appearance/typography preferences are applied, plus a double rAF so styles commit before reveal. All under a 2.5s safety timeout so a slow/offline CDN can't block startup. * feat(mobile): native local notifications; APNs implemented but frozen The native app now delivers agent ready/error/question/permission events as iOS (and Android) Local Notifications: a native notifications API backed by @capacitor/local-notifications replaces the Web Notifications API (which doesn't display in a WKWebView), driven by the notification SSE stream now subscribed in the mobile app. Tapping a notification opens its session. Also fix the settings toggle, which treated the Capacitor app as a browser and gated 'Enable Notifications' on the absent Web Notification permission, leaving it un-toggleable. Remote APNs push is implemented end-to-end (dependency-free HTTP/2 + ES256 JWT server runtime, token routes, client registration, iOS native config) but kept dormant: config-gated so it never fires, client registration not wired, and the aps-environment entitlement / background mode removed so the app builds with no Apple push setup. It will be reused once OpenChamber ships its own encrypted relay so users don't each configure APNs. See notifications/APNS.md. WKWebView can't use web push (unlike an installed PWA), so true background-when-suspended delivery on native requires APNs via that relay. * feat(mobile): APNs relay-mode background push Deliver native iOS background push through the central relay: the server posts device tokens + generic, model-based text to api.openchamber.dev/v1/push/send (default), which holds the single APNs key and signs+sends; dead tokens (410) are dropped from the per-session store. Direct APNs (HTTP/2 + ES256 JWT) stays as a fallback when OPENCHAMBER_PUSH_RELAY_DISABLED=true. The mobile push payload is generic only (model + scenario) so no session content crosses the relay. Re-enable the client token registration (useNativePushRegistration) and the aps-environment entitlement (alert pushes need no background mode). Wired into the same fanout as web push; focus-suppressed and only when tokens exist. * fix(mobile): APNs-only native notifications, generic templates, no foreground Make APNs the single notification channel for the native app and fix delivery: - Remove local notifications entirely (the @capacitor/local-notifications plugin and the SSE-driven path). A WKWebView can't tell foreground from background (document.hasFocus() is unreliable), so local notifications leaked while the app was open; the in-app dispatch is no-op'd on native. - Stop gating APNs on UI visibility — a backgrounded WebView can't report 'hidden' before iOS suspends it, which dropped background push. Instead always send and let iOS suppress the foreground banner (PushNotifications presentationOptions: []). - Fix a ReferenceError (out-of-scope 'variables') that crashed maybeSendPushForTrigger before any push was sent. - Mobile push text is generic: a scenario title ('Agent response is ready' / 'needs your input' / 'needs permission' / 'hit an error') + the session name, no model or message content. - Hide the focus toggle, templates, and test button in mobile notification settings. * feat(push): sign relay requests + bind tokens per server Each OpenChamber server now auto-generates an ECDSA P-256 keypair (persisted in settings, like the VAPID keys) and uses it to: - bind every newly-seen device token to the server on the relay (POST /v1/push/register-token, signed), and - sign every push send (publicKeyJwk + ts + signature over ts.sortedTokens.title). The relay derives serverId = SHA-256(publicKey), verifies the signature + timestamp, and only delivers to tokens bound to that server. Result: a leaked device token alone can no longer be used to push to a device — the sender also needs the server's private key. Stays zero-config (the keypair generates on first use). Drops the soft PUSH_RELAY_TOKEN bearer. * docs(push): describe relay data-confidentiality model Document that the push payload is not application-encrypted (TLS-in-transit only), what the relay and Apple can see (generic scenario title + session name, plus token/sessionId), that the signature is authentication rather than encryption, and what an end-to-end encrypted payload would require. * fix: invalid skill description * feat(push): app-icon badge for native notifications Send an absolute aps.badge with each native push = the count of distinct collapse-ids (tag) pushed since the app was last foregrounded, mirroring the lock-screen banner stack. Cleared server-side on user engagement (session view, message-sent, visibility beacon) and on-device via sceneDidBecomeActive. * feat(mobile): auto-connect last instance on launch + notification deep-links Cold launch silently reconnects to the most-recent saved instance (when reachable and a token is saved), holding the splash instead of flashing the connect screen; falls back to the connect screen when there's no saved instance, it's unreachable, or it needs a re-login. Notification-tap deep-links are now captured unconditionally (even before connect / on cold launch) and applied once the app is ready, so a tap opens the target session instead of being lost on the login screen. * fix(mobile): resolve theme background before first paint on cold launch The mobile shell entry (mobile.html) had no pre-paint theme step, so a cold launch flashed the WebView's default light canvas, then the baked design-system default (.dark { --background: #151313 }) via body.bg-background, before React's theme system injected the real theme vars. Add a blocking script that resolves dark/light from the persisted theme + system preference and sets --background (plus color-scheme and the element background) inline on the root, so the very first paint matches the resolved theme. Falls back to the default flexoki backgrounds when no theme has been persisted yet. * feat(mobile): openchamber:// deep-link foundation + arm64 simulator build Add a typed deep-link vocabulary (deepLinks.ts: parse/build + DeepLinkIntent) and a single native navigation layer (deepLinkNavigation.ts) that handles both the openchamber:// URL scheme (App.appUrlOpen — widgets, Live Activities, external links) and notification taps, normalising each into an intent. Session and new-session resolve against the store; shell surfaces (sessions/settings/ views/changes) register handlers. Cold-launch intents stash until the app is ready. Replaces the push-only useNativePushDeepLink and keeps backwards compatibility with bare sessionId payloads. Register the openchamber:// scheme in Info.plist. Dev tooling: with-mobile-env now honours xcode-select (-p) instead of hardcoding Xcode.app, so an Xcode beta is used. build:ios:simulator runs a new ios-sim-build script that temporarily drops the MLKit barcode-scanning pod (no arm64-simulator slice) so the app builds an arm64 binary installable on Apple Silicon simulators, then restores the Podfile + Pods for device builds. QR scanning already degrades cleanly when the native plugin is absent. * feat(mobile): iOS home/lock/Control Center widgets + push-driven refresh Add a Widget Extension (OpenChamberWidget) and a Notification Service Extension (OpenChamberNotificationService), wired into the Xcode project, sharing an App Group with the app. Widgets: - Overview (medium): recent sessions with read/unread dots + four quick actions (new, status, instances, settings). - Sessions (large): session list with per-session project label, attention count and a new-session button in the header. - Quick Actions (small): New chat pill + status/instances. - Lock Screen (accessoryCircular x2): brand logo to new session, attention counter. - Control Center control: brand logo (custom SF Symbol) to new session. Data: the app writes a session-overview snapshot (attention count + recent sessions with project labels) to the App Group on scene activate/resign; the NSE refreshes it from each push (aps.badge + sessionId) so widgets update even when the app is closed (needs aps mutable-content, added to the server + relay). Deep links: add openchamber://status (session status panel) and reuse view/instances; all widget taps route through the existing deep-link channel. * feat(mobile): large Sessions widget lists 6 sessions with project labels * feat(mobile): edge-swipe to switch sessions with directional slide+fade * fix(mobile): keep widgets in sync via reload-on-change + periodic refresh Widgets sharing the app's WidgetKit reload budget refreshed unevenly, leaving the large Sessions widget stale (no unread dot / attention count) while medium updated. Drop the per-call updatedAt from the snapshot, only write + reloadAllTimelines when the session overview actually changed (so we don't burn the budget on every scene activate/resign), and give each widget a periodic timeline refresh so a missed reload self-corrects. * feat(mobile): Android support — chrome fixes, SSE lock, icon, QR scan Cosmetics: - Status bar: on Android inset the WebView below the bar (overlay:false) and paint it with the resolved theme background + correct content Style, since Android doesn't feed env(safe-area-inset-top) to CSS. - Keyboard: skip the manual --oc-keyboard-inset on Android (the window resizes natively, so applying it double-counted and floated the composer); declare windowSoftInputMode=adjustResize and disable the shell height transition on Android so the header no longer bounces on keyboard open. Transport: lock Capacitor apps to SSE — native WebSocket streaming is unreliable on Android (events only arrive once a run finishes). Forced in sync-context and the other options are disabled in the Chat settings UI. Push: gate APNs registration to iOS only; on Android @capacitor/push-notifications register() needs Firebase/FCM (not configured) and crashes at launch. QR pairing: declare CAMERA permission + the ML Kit barcode_ui dependency, and install/await the Google barcode scanner module (with a post-install retry) before scanning so the first scan works without a manual retry. Icon: Android adaptive launcher icon generated from the cube logo (full-bleed white background, no edge artifact on One UI). Source assets under mobile/assets. Tooling: adb-based android-device.mjs + android:* scripts for device deploy. * feat(notifications): presence-aware push routing (don't spam the phone) Only push to a device when the notification would otherwise be missed there. A notification is suppressed on devices where the user is already present. - Tag every client's visibility beacon and web-push subscription with a platform ('ios' | 'android' | 'vscode' | 'desktop' | 'web') via getClientPlatform(). - Server tracks visibility per client (keyed by oc_ui_session) with the platform, and exposes isAnyInteractiveClientVisible() = any visible non-mobile client. - Native push (APNs) and mobile PWA web-push are now suppressed when an interactive (desktop/web/vscode) client is visible — it already shows the in-app notification. Gated on the desktop's visibility (reliable), never the phone's own (a backgrounded WKWebView can't report "hidden"). - Desktop/web web-push keeps the any-visible gate (a visible client absorbs it). - Skipping APNs also skips the badge increment so it doesn't drift. Fixes the case where every session on a shared instance pushed to the phone even while the user was actively working on desktop. * feat(mobile): Android FCM push notifications Enable native background push on Android via Firebase Cloud Messaging, in parallel with the existing iOS APNs path. - Add google-services.json + declare POST_NOTIFICATIONS (Android 13+). The Google Services Gradle plugin is applied when the file is present, so register() returns an FCM token instead of crashing. - Un-gate native push registration to iOS OR Android, and tag the registered token with its platform ('ios' | 'android') so the relay routes it to APNs vs FCM. - Server stores the platform per device token and binds it to the relay (platform included in the signed register message). - Notification small icon: monochrome cube silhouette with a mark on the top face, set as the FCM default_notification_icon so the status-bar icon reads as the logo. Relay-side FCM sending ships in openchamber-website. * docs(mobile): refresh HANDOFF with current state, dev/deploy process, and CI gap * chore(mobile): iOS store-review prerequisites (privacy manifest, encryption flag) - Add the app's PrivacyInfo.xcprivacy (no tracking; required-reason UserDefaults for the App Group snapshot shared with the widget + notification service extension) and wire it into the App target's resources — Apple requires an app-level privacy manifest. - Set ITSAppUsesNonExemptEncryption=false to skip the per-build export-compliance prompt. - HANDOFF: add a store-review-readiness checklist (in-repo vs release-time console/infra items). Verified: plist lint, xcodebuild parse, and an iOS simulator build with PrivacyInfo.xcprivacy bundled into App.app. * refactor(mobile): dedupe capacitor detection + make beacon guard explicit Addresses non-blocking PR review notes: - Consolidate the repeated Capacitor-native check (mobileConnections, deepLinkNavigation, usePushVisibilityBeacon each redefined it) onto the single isCapacitorApp() in lib/platform. - usePushVisibilityBeacon now guards on isWebRuntime() OR isCapacitorApp() instead of relying on isWebRuntime() being true for Capacitor, so the beacon can't silently stop if that changes.	2026-07-01 09:55:41 +03:00
3 people	f13f6d5540	feat(#1766): support OpenCode steer delivery / follow-up behavior settings (#1781) ... * feat: support OpenCode steer delivery / follow-up behavior settings Implements issue #1766 — steer delivery mode for mid-turn message insertion, replacing the old boolean queue-mode toggle with a tri-state follow-up behavior setting (Steer / Queue / Send immediately). - Plumbing: threaded optional delivery: 'steer' through sendMessage -> routeMessage -> opencodeClient.sendMessage -> promptAsync - Store: messageQueueStore stores followUpBehavior; migration from legacy queueModeEnabled persisted state - Settings: Chat -> Follow-up behavior shows three radio options using existing settings UI patterns - Composer: when session is busy, a floating queue button remains; force-sending a queued message (via chip click) uses delivery: 'steer' during a busy session; Steer button intentionally omitted — steer is available via the two-gesture path (Enter to queue -> chip to steer) - Keyboard: queue mode = Enter queues, Ctrl+Enter sends; otherwise Enter sends, Ctrl+Enter queues - Persistence: DesktopSettings, web settings payload, and server-side sanitizer handle the new key with legacy fallback - i18n: follow-up behavior section and option labels in all 9 locales plus new chat.chatInput.actions.queue label - Search: settings registry updated from chat.queue-mode to chat.follow-up-behavior Validation: type-check passes (no new errors), lint clean. * fix(#1766): make steer mode actually steer The followUpBehavior === 'steer' branch in handlePrimaryAction and the keyboard handler was a no-op — both fell into the else branch and sent without the delivery: 'steer' flag, so selecting 'Steer (insert into the running turn)' in settings produced identical behavior to 'Send immediately'. - handlePrimaryAction: when steer mode is selected and the session is busy, call handleSubmit({ delivery: 'steer' }) directly - Keyboard handler: in steer mode, Enter steers and Ctrl+Enter sends immediately (consistent with queue mode where Ctrl+Enter bypasses the special handling) Also removes the unused chat.chatInput.actions.queue i18n key from all 9 locales (it was a dead key after the Steer button was removed from the composer). Validation: type-check clean, lint clean. * refactor(#1766): flatten nested ternary in followUpBehavior resolution Replace nested ternary with explicit if/else chain per project code style (CONTRIBUTING.md). Import FollowUpBehavior type explicitly for the new let declaration. * feat(chat): drop redundant 'immediate' follow-up mode, keep Queue + Steer 'Immediate' was wire-identical to 'Steer' on a busy session: OpenCode only supports delivery 'steer' | 'queue' and defaults to 'steer', so an immediate send (no delivery flag) already steered into the running turn. The three-mode UI therefore exposed two settings that did the same thing. Collapse to two modes — Queue (unchanged: client-side queue with edit/reorder) and Steer. Any persisted/legacy 'immediate' (and legacy queueModeEnabled=false) now maps to 'steer', preserving prior behavior. Removes the immediate option, its keyboard branch, the i18n label across all locales, and narrows the followUpBehavior union to 'steer' | 'queue'. --------- Co-authored-by: Leonid Skorobogatyy <bash@opencode.itc.local> Co-authored-by: Bohdan Triapitsyn <artmore@protonmail.com>	2026-06-29 01:28:20 +03:00
Bohdan Triapitsyn	bf1d0d3a75	feat(mobile): polish composer model/agent controls and selection overlay ... Redesign the mobile composer model and agent buttons as borderless, full-bleed labels that hug their content, truncate with an ellipsis when space is tight, and show the provider logo inline before the model name. Tighten the footer action buttons (sessions / attach / auto-accept) so they sit close together, with a small left inset on the group. In the mobile model selection overlay, make the thinking-variant control text-only with a chevron, vertically center the variant and favorite controls in each row, and place the provider logo inline with the model name.	2026-06-28 13:33:55 +03:00
Bohdan Triapitsyn	1f549e4525	feat: add automatic review loop (#1840)	2026-06-26 19:29:44 +03:00
Tom Rochette	9a2012c94e	fix(chat-input): dismiss open question prompt when sending a message (#1740) ... Sending a message while a question prompt was open left the prompt lingering, blocked the send, or collided with the still-blocked agent turn. Two root causes: useSessionActivity treated pending permissions as idle but not pending questions, so the send button became Stop during a question and Enter queued/collided instead of sending. handleSubmit also never dismissed the open question, stranding the session in a half-answered state. The send path now dismisses open questions for the session subtree (optimistic local clear so the card vanishes instantly, plus a formal question.reject) and queues the message. The queued-message auto-send hook then delivers it as the next turn once the rejected turn winds down and the session returns to idle. Queueing avoids aborting the turn, which surfaced an unwanted "running turn was stopped" notice. Regression tests cover the no-op, subtree dismissal (root + subagent child), and QuestionNotFoundError paths.	2026-06-25 10:55:35 +03:00
Bohdan Triapitsyn	3d3674d4dd	fix: restore arrow-up message history navigation ... Lets ArrowUp recall previous messages when the cursor is at the start Keeps autocomplete guards for history navigation Restores prior chat input behavior	2026-06-23 23:21:09 +03:00
Nicolas CharpentierandBohdan Triapitsyn	b87de3c5b2	fix: ignore pasted @ for file mentions (#1649) ... Co-authored-by: Bohdan Triapitsyn <artmore@protonmail.com>	2026-06-23 14:07:09 +03:00
bashrusakh	59ecd86b4b	perf: isolate chat streaming renders and reduce sidebar render cost (#1672) ... Reworks the chat and session-sidebar render paths to cut render cascades, memory churn, and UI jank on large sessions and big session trees. Behavior is preserved; the changes are about *when* and *how much* the UI re-renders. ## Chat streaming - Freeze the streaming message's parts in the bulk turn projection during streaming, and re-inject live parts only in an isolated tail leaf, so a ~60/sec delta stream no longer re-runs the whole-session projection or re-renders unrelated rows. session with referential reuse of unchanged turns. - Memoize message rows with field-aware comparators instead of reference equality. - Replace the manual child-session polling in the task tool with the live SSE stream + a one-shot load, removing a fetch/settle state machine. ## History loading & scroll - Load an initial page fast, then prepend one older page in the background so the scroll container has headroom and "load older on scroll-up" fires before the user hits the absolute top. - Compensate scroll synchronously (in a layout effect, before paint) for prepends — including background prepends that don't originate from a user scroll — so the viewport stays stable instead of judder-correcting on the next frame. ## Markdown rendering - Render markdown synchronously *styled* on first paint (paragraphs, lists, code cards, tables, inline code) instead of raw escaped text; the async pass then only upgrades syntax-highlight colors. Eliminates the flash of full-width raw text. - Load KaTeX CSS eagerly with the main bundle instead of inside the lazy markdown chunk, avoiding a late stylesheet injection on first render. ## Sidebar - Hoist per-row recursive tree walks out of row comparators into per-group precomputed sets/keys; batch live-session lookups into a single map; add a group-level memo boundary. - Isolate rename drafts so per-keystroke typing doesn't repaint the row tree. ## Sync layer - Add a staleness guard so a slow message fetch can't repopulate a session the user navigated away from. - Throw on fetch failure for authoritative loaders so a transient blip can't read as an empty server response. ## Cleanup - Remove dead code (unused hooks, params, duplicated inline types) surfaced while reworking the above. ## Known issue - A rare, purely cosmetic first-paint width flash can still appear on large sessions; it has no behavioral or data impact and is tracked for a follow-up runtime trace.	2026-06-18 00:43:16 +03:00
Bohdan Triapitsyn	c22e1cbb15	refactor(chat): remove dead syntaxTheme plumbing ... The Prism syntaxTheme prop is no longer read after code highlighting moved to the Shiki worker. Remove the now-dead prop threading and its source. - Drop syntaxTheme from interfaces, destructures, prop passes, and React.memo comparators across ChatMessage, MessageBody, ProgressiveGroup, ToolPart, TurnActivity, ToolOutputDialog, and ChatInput. - Drop the unused _syntaxTheme param from renderWebSearchOutput. - Remove the dead generateSyntaxTheme usages (ChatMessage memo, PlanView unassigned memo) and delete the now-unimported syntaxThemeGenerator module.	2026-06-16 01:07:43 +03:00