Product updates.

Kickserve now has a clearer foundation for future model-provider work and a more flexible workspace layout for active development sessions.

• Added a Codex provider capability inventory to document what the current runtime supports and where future providers should fit.
• Added center split view support, active split-pane tracking, pane session menus, project menus, and safer close behavior that promotes remaining panes correctly.
• Improved split-pane drag-and-drop targeting, single-column behavior, native file-drop hit testing, and split controls.
• Persisted session git branch context and added hover details so session state is easier to understand at a glance.
• Stabilized chat transcript item identity to reduce visual churn in active conversations.
• Added runtime coverage for prepared thread reuse and tightened app-server shutdown and terminal error handling.
• Stopped the floating composer from auto-opening or hijacking focus during initial thread preparation.

Kickserve's Codex integration received a focused runtime pass to make startup behavior easier to measure and reason about.

• Normalized the app-server PATH so Kickserve can find the user-installed Codex binary more reliably.
• Cached the resolved Codex path to avoid repeating expensive lookup work.
• Added guards and logging around first-token timing so startup latency can be inspected with better evidence.
• Clarified the provider architecture documentation and separated runtime orchestration from the broader capability model.

Kickserve made the chat surface more useful for real project work by carrying attachments through queued messages and making transcript links actionable.

• Added queued file attachments across the main chat surface and composer flow.
• Added file-link actions for markdown messages so local project references can open from the transcript.
• Added external URL handling for assistant markdown output.
• Added compact size variants across git, transcript, and floating-composer surfaces.
• Reduced repeated change-summary rendering so each turn presents file changes more cleanly.

The floating composer became a more complete companion surface for working across projects and sessions without losing draft state.

• Added a stop action for active floating sessions.
• Added multi-layout support, header controls, project/session menus, and refined floating composer popovers.
• Preserved unsent drafts per chat and moved draft state into a centralized store shared across composer surfaces.
• Added per-thread cleanup and tests for chat draft persistence.
• Enabled steering control for queued messages across the composer UI.
• Added a context usage indicator to the floating composer.
• Normalized commit messages before commit or push actions.

Kickserve received a major architecture consolidation pass across the React shell, Tauri bridge, git tools, and Codex app-server integration.

• Centralized app preferences with optimistic UI updates for dock and shell settings.
• Moved pane, terminal, and UI state into a focused Kickserve UI store.
• Refactored the app shell into dedicated hooks and shell model builders for labels, polling, errors, and layout state.
• Modularized the git pane, git diff viewer, git command handling, and AI-assisted commit-message generation.
• Added branch listing and switching, paginated commit history, infinite scroll, richer diff previews, and optional file contents in git diff views.
• Scoped side-preview, file, and diff selections to the active workspace.
• Added unread counts and read-state tracking for Codex sessions.
• Refactored Codex session actions, transcript state, queued message transport, app-server protocol code, and Tauri integration into focused modules.
• Added tests for shell models, side-preview behavior, session actions, and migrated broader test coverage into smaller files.
• Replaced per-pane headers with a shared pane header and added compact git status affordances in the right pane.
• Applied assistant markdown styling to transcript rows.

Kickserve added the approval flow needed for real Codex sessions that pause for user confirmation.

• Added Codex approval request handling and related preference support.
• Improved approval notifications with actionable macOS behavior and registry handling.
• Added collapsible project sections and session visibility controls in the left pane.
• Improved git pane theme propagation, accessibility, and visual polish.
• Fixed floating composer launch positioning, sizing, and anchor updates.
• Added a chat scroll-to-bottom control and frame-height reporting for the chat surface.

Kickserve's floating composer moved closer to a native desktop companion window.

• Applied macOS floating composer material and adjusted native window sizing.
• Added haptic feedback support for macOS interactions.
• Enabled image previews in workspace browsing and git diffs.
• Added native commands for floating composer window toggling.
• Added pending-session support and improved project grouping in the floating session dock.
• Added keyboard shortcuts and preferences for dock concealment and floating window behavior.
• Stabilized dock ordering and session grouping.
• Added drag support from the floating composer header.
• Added chat completion alerts through updated Tauri/Codex server integration.

Kickserve expanded from a single chat surface into a richer development workspace with git context and background-friendly session controls.

• Added support for queueing and steering messages while sessions are active.
• Optimized chat scrolling performance and added more test coverage.
• Added git history and diff views.
• Expanded git diff previews with file contents and refined patch separator styling.
• Styled Sonner toasts to match Kickserve's theme.
• Introduced the first floating composer window with optimistic session generation.
• Added project and session menus to the floating composer.
• Enabled queued messages in the floating composer and session activation reactions.
• Removed an earlier AI-generated commit-message integration path while the app-server wiring was being cleaned up.

Kickserve now has an early desktop preview for local projects.

• Open a project from your machine.
• Keep the codebase, conversation, and project context in the same workspace.
• Let agents work with the files that actually define the product.

This preview is the foundation for making Kickserve feel less like a blank chat box and more like a product-aware workspace.

Kickserve tightened a few important reliability edges around active sessions and summary review.

• Made stop_codex_session idempotent and best-effort so repeated stop requests are safer.
• Fixed undo behavior in the summary card.

Kickserve's internals were reorganized around smaller, clearer Rust and React modules while the desktop shell received another polish pass.

• Split the native backend into focused Rust modules.
• Moved git command handling into its own module and organized backend modules into folders.
• Extracted pure Codex helpers, registry code, transcript handling, app-server transport, and session commands.
• Removed the legacy Codex CLI fallback path after the app-server transport became the main integration path.
• Refactored the chat surface and supporting components.
• Pruned the earlier launch-readiness/scanner experiment to keep the MVP focused on the Codex replacement loop.
• Adjusted file pane controls, terminal toggle placement, and file viewer width.
• Added native macOS brand-mode backing with CAGradientLayer.
• Implemented macOS window zoom-rect synchronization.
• Added additional loading, truncation, and general UI fixes.

Kickserve made the chat composer more capable and moved a large amount of styling into clearer ownership boundaries.

• Added file change summaries directly in the chat transcript.
• Overlaid the chat composer over the transcript and added project context in the composer header.
• Added workspace color accents to the chat UI.
• Refined composer actions and styling.
• Added file attachment support and a dropzone.
• Added a dedicated git menu.
• Refactored global CSS into Tailwind and component-owned styles.
• Moved shell layout and markdown styling out of broad global CSS.

Kickserve improved the daily reading experience across source files and Codex transcripts.

• Improved the Shiki-powered file viewer.
• Fixed sidebar highlighting.
• Improved markdown rendering.
• Added autogenerated chat session titles.
• Grouped transcript activities and refined command display.
• Added support for copying sent messages and chat responses.
• Collapsed completed work logs in the chat transcript.

Kickserve made project browsing more comfortable and improved the native window experience.

• Updated product and development docs.
• Improved the workspace file tree.
• Fixed macOS window reveal behavior.
• Added theme selection.
• Improved file tree state management.
• Added Shiki syntax highlighting to the file viewer.

Kickserve received a focused quality-of-life pass across the early desktop workspace.

• Smoothed early workspace interactions after the first Codex, file, terminal, and layout features landed.
• Continued tightening the app experience before the larger transcript, composer, and backend refactors that followed.

Kickserve agents now share the same project context instead of starting from scratch.

• Legal agents can inspect what data your app collects before drafting policies.
• Email agents can work from real product flows instead of generic templates.
• Analytics and launch agents can connect their recommendations to actual routes and features.

The goal is simple: the codebase becomes the brief.

Kickserve's early desktop shell became more recognizable as a shippable macOS app.

• Refined the layered sheet layout and native window controls.
• Fixed chat transcript scrolling when sessions load.
• Split chat and terminal bundles for a cleaner app structure.
• Moved the terminal into the bottom panel.
• Added running indicators and shimmer-style thinking text.
• Updated Tauri configuration with the main binary name, macOS bundle name, and application icons.
• Added GitHub Actions CI and release packaging.

Kickserve took its first big step toward replacing the Codex app as the founder's daily workspace.

• Added highlighted file and terminal rendering.
• Added a durable Codex session console.
• Added a git worktree manager.
• Added an embedded PTY terminal.
• Improved Codex chat streaming and transcript rendering.
• Deferred Codex sends off the UI thread for a more responsive interface.
• Added Codex thread preparation and warmup hooks.
• Preserved whitespace in streaming Codex deltas.

Kickserve started as a local-first macOS desktop workspace for building real projects with Codex.

• Scaffolded the Kickserve MVP foundation.
• Added native build setup, lockfile, and placeholder app icon.
• Built persisted workspace state.
• Added the first Codex process adapter surface.
• Added a workspace scanner readiness contract.
• Added a native smoke test runner.
• Aligned the frontend foundation with the Conductor-style stack.
• Added a native workspace folder picker.
• Added the first parallel feature sprint plan.
• Extracted app shell panes.
• Persisted Codex session lifecycle data.
• Added a scanner-backed launch readiness preview.
• Added a workspace file viewer surface.
• Polished workspace shell navigation.

Readiness checks help surface the product work that usually sits around a code change.

• Find launch, legal, email, analytics, and support follow-ups before release.
• Turn code changes into practical next steps.
• Keep shipping work visible without turning it into a separate planning system.

This is the first pass at Kickserve's product layer around coding agents.