Issues & classifications

Architectural redesign of the live-to-final assistant reply lifecycle spans streaming backend and core chat frontend rendering.

Localized navigation bug where unsent composer draft state is discarded on session switch rather than persisted.

Localized conditional rendering of the Plugins tab based on empty state from the existing API endpoint.

Cross-cutting change to inject scheduled job outputs into chat sessions requires new backend message plumbing and frontend rendering.

Missing tilde expansion in workspace path inputs likely stems from a frontend normalization gap or backend resolve mismatch.

Architectural addition of a subprocess-isolated plugin bridge spanning API routing, process lifecycle management, and frontend proxy integration.

Security hardening to close TOCTOU races across multiple file-API route handlers using anchored file descriptors.

Need to add role-sequence normalization to both in-process and gateway chat paths to prevent consecutive user turns.

New PDF export capability requires integrating generation logic and UI hooks for themed, markdown-formatted conversation output.

Redesigning sidebar filtering requires moving controls from Settings, adding multi-select popover state, and updating session APIs.

Profile provider resolution falls back to global defaults instead of the profile-bound configuration in session routes.

New chronological transcript view requires refactoring assistant-bubble rendering and styling logic across the chat canvas and replay components.

File-manager drag-and-drop requires new backend move/upload endpoints and extensive frontend workspace tree event handling.

Small additive UX enhancement to surface existing backend save events via frontend notification toasts.

Localized async state-management bug in stream cancellation logic with precise acceptance criteria confined to boot and toast utilities.

Adds post-onboarding Settings UI for self-hosted providers, requiring provider metadata, base-URL editing, probe endpoints, and onboarding flow integration.

Replacing static MiniMax model lists with dynamic auto-refresh touches catalog config, models endpoint, and frontend switcher.

Plugin discovery works in CLI but registry remains empty in the WebUI process, suggesting a cross-cutting import/timing or upstream API issue requiring deep investigation.

Simple threshold bump or environment-variable wiring for existing markdown preview limits.

Structural packaging refactor touching entrypoints, build config, and deployment scripts with no behavior delta.

Straightforward CSS color-variable update for an existing skin palette.

Safely rendering generated HTML in chat requires architectural frontend sandboxing/iframe work plus backend sanitization, touching the renderer pipeline across UI and API layers.

Adds trusted-header authentication and profile binding across the API server, configuration loader, and deployment environment definitions.

Precisely localized conditional bug where topbar source-badge logic incorrectly gates on is_cli_session instead of available source metadata fields.

Fixes misclassification of compression-exhausted tool-tail streaming turns as finalized responses by updating terminal-error handling in streaming and transcript persistence.

Pure frontend management feature following an established session sidebar pattern without new backend persistence complexity.

Cross-cutting push-notification system needs service worker handlers, subscription API, VAPID backend, and PWA manifest updates.

UX enhancement to allow message queuing during compression, touching composer state machine and i18n strings.

Introduces global or per-session preference logic to guard manually set titles from automatic regeneration, spanning session store, settings UI, and API.

Documentation-only update specifying tested Hermes Agent versions and release compatibility policy for operators.

Self-contained Dockerfile change adding GPU user-space libraries to enable hardware-accelerated workloads in container deployments.

Fixes stale TUI/CLI session titles by extending the WebUI rename endpoint to propagate through to the agent state database.

Intermittent context-window misreporting likely stems from frontend state or streaming payload parsing.

Fixing German false-positives in `_detect_title_language` and removing hardcoded literals is a localized bug fix in the streaming module.

Lightweight UI addition of static outbound links to documentation and GitHub issues in the nav or Settings panel.

Session rename failure is likely a localized bug involving a frontend event handler and its corresponding API endpoint.

Localized mobile frontend change adding a single new-chat button to the titlebar alongside existing sidebar control.

Restructures sidebar session grouping to visually nest forked sessions under parents with collapsible UX and corrected chronological placement.

New session-status UX requires frontend sidebar rendering, backend session model updates, and persistence.

An intermittent, unreproduced race condition between the workspace dropdown and session state spans frontend and backend with unclear scope.

Race condition between environment variable restoration and daemon thread initialization requires thread-safety fixes.

Core context-management defect spanning compression algorithm, streaming integration, and frontend state sync; architectural complexity.

Frontend durability bug requiring changes to sessionStorage/localStorage mirroring, boot restore logic, and draft session classification.

Specific import failure suggests a dependency version mismatch fixable by pinning or updating an import path.

New profile-toolset resolution capability bridging backend profile config with frontend composer UI.

Re-architecting WebUI into a thin client over Hermes Agent is a fundamental, cross-cutting redesign of the entire server and frontend execution model.

User-contributed ARM64 mobile performance data point to be incorporated into existing documentation and examples.

Kanban worker incorrectly transitions tasks to 'done' when non-interactive approval fails rather than moving them to a 'blocked' state.

Architectural RFC redesigning core run-state and intent-durability contract across frontend and backend.

The issue contains only a screenshot with no reproduction steps, error messages, or context, making it impossible to scope the necessary fix.

Displaying real-time token throughput in the message footer requires frontend streaming UI changes and possibly backend metering event integration.

Localized UI enhancement adding shortcut affordances to existing MCP tool list in frontend panel code.

Unexpected auto-compression timing and duplicated message rendering point to a streaming-state bug around the compression boundary in both frontend and backend.

Adding stable and nightly release channels requires cross-cutting changes to CI/CD pipelines, container builds, deployment scripts, and release infrastructure.

Restoring the visible-progress contract requires changes to both API streaming logic and frontend chat rendering for tool-based assistant turns.

Adding a collapse toggle to the approval popup is a localized frontend UI change.

Adds an in-app configuration editor tab, requiring a new frontend panel and backend endpoints for safe read/write of config.yaml.

Major UX restructuring of global vs. contextual navigation with new split-panel sidebars, requiring broad changes across the frontend architecture.

Attachment handling incorrectly passes a display-only virtual path to the agent instead of resolving the real filesystem path, breaking file tool usage.

This is a support question about persona storage location, signaling a documentation gap that can be resolved by updating docs or the README.

Cost-protection pauses require new backend risk-signal accumulation and a frontend UX to present pause choices and resume or stop runs.

Multi-peer remote dispatch is an architectural feature affecting gateway routing, coordinator logic, and WebUI peer identity surfaces.

Interactive visualizations require extensive renderer extensions, new frontend libraries, and export/import infrastructure.

Forcing skill attachment requires new frontend skill-selection controls and backend logic to inject skill content into the conversation context.

Adding an auto-expand preference for panels is a localized change to frontend settings and panel rendering behavior.

Tracking and implementing targeted session-switch latency optimizations requires frontend rendering pipeline changes.

Multi-layer authentication umbrella covering user tables, optional 2FA, and external IdP integration spans the auth backend, onboarding, and frontend login flows.

Requires adding session-scoped override UI controls and backend state management while preserving global defaults.

PWA blank-screen after update likely involves service-worker caching, build asset versioning, or deployment headers, but the needinfo label and mobile-specific reproduction make the scope unclear.

Introduces a new knowledge-base browser with search and edit capabilities, requiring new backend endpoints, data access patterns, and a dedicated frontend surface.

Performance bug rooted in timeout estimation, streaming-state misdetection, and run lifecycle management requiring deep cross-layer investigation.

Three interrelated streaming/compression-boundary symptoms that brick sessions and silently downgrade models indicate a cross-cutting backend-frontend state bug requiring deep investigation.

Issue contains only a screenshot with no textual description, reproduction steps, or expected behavior, making classification and scoping impossible.

A new user-facing prompt library requires a dedicated frontend UI, storage integration, and likely backend persistence, touching multiple components.

Exposes LLM token metrics (input/output/cache) in the UI, requiring propagation of provider telemetry through the API layer and new frontend components.

Self-contained frontend enhancement adding fuzzy filtering and keyboard navigation to the existing model selection dropdown.

Adds a user preference and end-to-end filtering logic to surface cron job sessions in the chat sidebar.

Internal audit and hardening of TLS-dependent database callers to prevent the same background-thread race addressed in #2827.

This is a localized process-reaping bug in api/terminal.py that can be fixed by applying the established subprocess lifecycle pattern.

Memory leak leading to complete session freeze requires deep cross-cutting investigation into server and session management.

Deployment-specific configuration gap where the gateway is not configured in the Docker image, most likely requiring documentation for scheduled jobs to run correctly.

Inconsistent HTTP semantics between GET and POST session endpoints require coordinated fixes in API handlers and frontend session-resolution / boot logic.

Paste rendering works but the attachment is appended after streaming ends, indicating a message-assembly or multimodal payload bug spanning frontend composer and chat API handlers.

Architectural enhancement to formalize and enforce consistency invariants across streaming, recovery, replay, and compression subsystems.

Architectural overhaul to enable persistent bidirectional synchronization between gateway runtimes and the WebUI session store.

Adding an existing sidebar tab to the appearance toggle list is a localized frontend settings change touching only a few files.

Attachment blob URLs cannot be read as disk paths in the streaming handler; requires aligning frontend upload delivery with backend file reading.

Request to integrate scripts into the task section is a localized UI enhancement.

Straightforward frontend addition of a profile switcher to the main chrome without backend changes.

Environment-driven profile isolation failure spans backend bootstrap configuration and frontend profile selection, but needinfo reduces certainty.

UX refactor to relocate per-session todos into the workspace side panel, affecting several frontend components.

Localized enhancement to SSE payload and browser handler to filter events by active profile.

New dashboard plugin discovery, routing, and iframe rendering system spanning API and frontend.

New text-based Canvas editing surface requires major frontend components, partial-context backend streaming support, and session-history integration.

Issue conflates a vague /clear corruption bug with a new reload feature request and lacks sufficient reproduction details.

The bug spans the agent's concurrent and sequential tool execution core, requiring careful changes to steer state management and tool-call interruption semantics.

Filtering the session list by workspace touches the sidebar rendering, preferences pane, backend session queries, and workspace metadata normalization.

New frontend interaction pattern requiring chat canvas selection handling, floating popup UI, and composer context management.

Broad question about profile/workspace usage lacks concrete reproduction steps or a specific proposed change.

Enabling host-side file manager reveals from inside a container requires new configuration plumbing, API path-mapping logic, and orchestration updates.

This is a straightforward visible enhancement replacing static logo assets with no application logic changes.

Adding avatar display requires modifying the chat canvas rendering logic, profile configuration, and associated styles without breaking the existing message pipeline.

Security-sensitive authentication mode integrating PAM, server-side profile binding, and session authority.

Implementing detachable, nameable context blocks in the composer requires new UI components, selection state handling, and composer interaction logic.

The MiniMax provider is writing reasoning tokens into persisted messages without corresponding content, causing malformed message records in session storage.

Swapping static SVG assets and theme CSS for a redesigned logo is a localized cosmetic frontend change.

Supporting external messaging channels requires architectural changes to the API namespace whitelist, stale-session eviction logic, and frontend sidebar filtering.

Cross-cutting architectural refactor to replace direct filesystem coupling with a stable, container-spanning API contract.

Adding CSRF tokens, app-wide CSP, and secure cookie heuristics introduces new security capabilities across the API auth layer and frontend.

Architectural enhancement to eliminate inter-container filesystem coupling by establishing a formal API boundary.

Adding a NixOS installer requires new packaging configuration, lock files, and documentation updates across the DevOps toolchain.

Frontend UX enhancement requiring chat timeline rendering, dynamic collapse behavior, and activity-group-aware layout adjustments.

Cross-cutting UX architectural realignment affecting multiple panels to match the heavy Hermes backend profile runtime model.

Adding a provider-neutral memory approval queue requires new backend endpoints, frontend UI components, and persistence integration.

Suspected memory leak causing recurrent crashes demands open-ended profiling across the Python server and session lifecycle.

Runtime-configurable upload limits require coordinated changes across backend API, browser preflight logic, and archive extraction.

Conversation outline panel requires new sidebar UI, scroll-to-message logic, and lazy-loading integration.

Adding a workspace side-panel show/hide toggle is a scoped frontend UX change.

Designing a durable worktree lifecycle and safety model for non-process-scoped WebUI sessions is architectural feature work.

GPU remaining active after stream completion indicates a missing cleanup or close event in the chat streaming lifecycle.

Well-scoped renderer parity fix adding MEDIA: token parsing to a single React component.

Localized turn-journal hardening adding explicit double-terminal detection and append-safety guards.

This is a one-shot legacy data migration with an idempotent script and regression test, falling under internal maintenance.

Splitting the monolithic 8,584-line api/routes.py into per-domain modules is a straight internal refactor to reduce conflicts and improve modularity.

Cross-cutting cost tracking requires new backend data collection, chart rendering, budget configuration, and alerting across the API and frontend.

Tracking an upstream agent-side concurrency fix is a dependency coordination task with no direct WebUI code changes required until hermes-agent lands the re-key.

Extending the existing quota endpoint for multiple providers and adding a persistent topbar indicator spans backend provider logic and frontend chrome components.

Gateway startup/shutdown configuration likely involves lifecycle hooks and config parsing, but the image-only body leaves exact scope ambiguous.

Cross-cutting storage migration requiring data migration, transition flags, API model changes, and coordination with upstream CLI SessionDB.

Multi-format office document support and Google Workspace integration span dependency management, upload pipelines, backend parsing, external API integration, and UI rendering.

Refactoring synchronous subprocess spawns into a long-lived, profile-isolated worker pool is an internal operational improvement with no functional delta.

Concurrency bug in shared process environment isolation requiring careful changes to agent execution spawning and per-session env handling.

Adding a browser Geolocation API button to the chat composer is a localized frontend enhancement with minor backend message-schema changes.

Converting hidden slash commands into visible UI actions requires coordinated changes across frontend command handling, new toolbar components, and existing backend command dispatch.

Needs hierarchy API endpoint and custom frontend tree-view component to visualize agent relationships.

Cross-cutting provider and model source-of-truth governance spans frontend state, API configuration, and runtime resolution across the WebUI and gateway.

macOS-specific TCC permission bug in agent file-search logic requires protected-path exclusions and possibly build-configuration or entitlement updates.

Architectural feature requiring a new MCP server implementation and push-based data flow across all dashboard panels.

Two new monitoring tabs requiring third-party API integrations, external service configuration, and substantial backend/frontend work.

Design reference artifact and prototype example attachment supporting related dashboard feature requests.

New team management panel with editable agent properties requiring both frontend UI and live config persistence.

Agent addition and model replacement modals requiring session state mutations without a server restart.

Purely cosmetic dashboard styling and layout adjustments with no underlying functional changes.

Searchable tool inventory panel aggregating tool metadata across all configured MCP servers.

Real-time categorized event log panel requiring streaming infrastructure and frontend rendering.

Requires new API endpoint to aggregate model metrics and a frontend comparison table with replacement recommendations.

Dismissible banner UI plus backend threshold evaluation and alert state management touches multiple layers.

New per-agent hallucination metric backend tracking and frontend display with configurable thresholds.

Quality score calculation and color-coded progress bar require backend metric aggregation and new frontend UI components.

New user-facing search capability requiring per-model toggle UI, settings persistence, and backend SearXNG integration.

Designing and integrating a write-ahead log for in-flight tokens touches the core streaming pipeline, session persistence, and crash-recovery architecture.

Removing a well-scoped legacy environment-variable alias is a localized internal cleanup with no user-visible behavior change for current setups.

Requires aligning gateway/WebUI session identifiers and extending existing approval polling UI to gateway-originated sessions.

Supporting multiple external agent storage formats and integrating them into the existing session sidebar is cross-cutting and architecturally complex.

New Tauri desktop app is a cross-platform architectural addition involving Rust, build pipelines, and WebView interop, estimated at well over two days.

Fundamental chat UX restructuring requires new frontend visualization stages, streaming state machine changes, and message formatting logic.

Self-contained frontend performance optimization touching list rendering components with IntersectionObserver but no backend API changes.

A new CLI connector requires building an installer, remote authentication, and network tunneling logic across new and existing components.