197 Commits

Author	SHA1	Message	Date
kshitijk4poor	24b33d42e0	fix(honcho): every honcho.json writer holds _refresh_lock and reads strictly ... The CLI's _write_config took only the best-effort file lock, so an in-process refresh thread could still interleave with a command's read-modify-write. The dashboard's Honcho save (_write_provider_honcho) still seeded its whole-file rewrite from a tolerant reader, so a honcho.json that exists but does not parse was replaced by the active host's block alone from the UI - the same bug class this PR closes on the CLI and refresh paths. `hermes profile create --clone` swallowed the new ConfigWriteRefused as "plugin not installed". One parametrized test covers the web writer for the corrupt and parseable cases.	2026-09-13 19:05:28 +05:30
teknium1	08dfa32da7	fix(dashboard): profile-create validates the model in the dashboard's home, reports rejections ... _write_profile_model validated under the NEW profile's HERMES_HOME. A just-created profile has no providers:, no .env and no auth, so every non-env provider the create dialog offered (anthropic, ollama, providers:-keyed custom) came back 'Unknown provider' / 'Could not resolve credentials' and create returned a silent model_set: false. The picker read THIS dashboard's catalog, so validation now runs scoped to the process home (validate_in) while the write still lands in the new profile. PUT /api/profiles/{name}/model keeps validating in the target profile (it is an existing, credentialed home). A real rejection now surfaces as model_error in the create response instead of a log line.	2026-09-13 05:21:02 -07:00
teknium1	11576390fe	refactor(model): one persist writer for /model across CLI, gateway, TUI, dashboard; ACP + dashboard validate through switch_model ... One `/model --global` produced four config.yaml shapes. CLI wrote default/provider/base_url/api_mode and cleared the context pin on a route change; the gateway rewrote the whole `model:` block (whole-file save_config) and only set api_mode for `custom`; the TUI wrote three keys and never touched api_mode, so a switch off an Anthropic-wire endpoint left a stale `api_mode: anthropic_messages` in config; the dashboard main slot had its own switched-provider logic, wrote `base_url: ""` and always dropped context_length. ACP `session/set_model` and `POST /api/model/set` accepted any model string (parse_model_input + detect_provider_for_model) so a model no catalog knows, or a provider with no credentials, was handed to the session / persisted and only failed at inference time. Canonical: `hermes_cli.model_switch.model_selection_config_updates` (the shape) + `persist_model_selection(result, config_path=None)` (targeted per-key `atomic_roundtrip_yaml_update` writes, so sibling `model_slots`/`model_fallback` keys survive; explicit path for the multiplexed gateway's profile config) + `apply_model_selection` (same shape applied to an in-memory `model:` dict for callers that save a whole document). `atomic_roundtrip_yaml_update(value=None)` now REMOVES the key instead of writing `key: null`, so per-key and whole-document writers land the same file. Shape = CLI/gateway semantics: default, provider, base_url (cleared when the target has none), api_mode (cleared when unresolved), context_length cleared only when `should_clear_context_pin` says the route identity changed, inline api_key/api cleared for non-custom targets. Sites -> canonical: hermes_cli/cli_model_switch_mixin.py::_persist_global_switch -> deleted; _commit_model_switch calls persist_model_selection hermes_cli/cli_model_switch_mixin.py::_clear_persisted_context_for_model_switch -> deleted (folded into the shape) gateway/slash_commands_model.py::_persist_model_switch_to_config -> to_thread forwarder: persist_model_selection(result, ctx.config_path) tui_gateway/model_switch.py::_persist_model_switch -> deleted; _apply_model_switch calls persist_model_selection hermes_cli/web_server_config.py::_apply_main_model_assignment -> apply_model_selection(result) (+ explicit custom api_key) hermes_cli/web_server_config.py::_validated_main_model_selection -> NEW: switch_model(--provider) gate; rejection -> HTTP 400 hermes_cli/web_routers/{models,profiles,config_env}.py main-slot paths -> through _validated_main_model_selection acp_adapter/server.py::_resolve_model_selection -> deleted; _switch_model calls switch_model (provider:model -> --provider), rejection -> ValueError Behavior changes: TUI --global now writes/clears model.api_mode and clears a route-changed context pin; gateway --global no longer rewrites the whole model block (sibling keys survive) and clears api_mode for every target; dashboard main slot / profile-create model / custom-endpoint activate now reject unknown/uncredentialed/unlisted models (HTTP 400) and persist the resolved base_url/api_mode instead of `base_url: ""`; ACP rejects the same (ValueError surfaced by the command/protocol handler). Gateway persist runs on a worker thread against the routed profile's config_path (multiplex-safe). Cleared keys are removed from config.yaml rather than left as `null`. ACP still never persists. Kept `_normalize_main_model_assignment`: switch_model rejects a vendor name posing as a provider (`moonshotai` -> "Unknown provider"), so the vendor->aggregator repair is not a duplicate; E2E verified both branches. No config migration: readers already coalesce `base_url: ""` to absent (`_config_base_url_for_provider`) and gate api_mode on provider match (`_provider_supports_explicit_api_mode`), so no stale-shape reader bug. Tests: tests/hermes_cli/test_model_persist_one_shape.py (four surfaces land one block; same-route re-pick keeps the pin), tests/acp_adapter/ test_acp_dashboard_model_switch_validation.py (rejection + explicit provider prefix). Replaces test_acp_set_model_explicit_provider.py and the two TUI-only persist tests; tests that intercepted the old per-surface seams (`cli.save_config_value`, `load_config_readonly`, `tui_gateway.server. _persist_model_switch`) now intercept the canonical seam. Each fix sabotage-verified red.	2026-09-13 05:21:02 -07:00
teknium1	fd5693bc92	fix(config): kanban decompose and local-models status keep their fail-open config reads ... Repointing the two _load_config copies at load_config_readonly() dropped the except-Exception guards the old copies had. load_config_readonly runs ensure_hermes_home(), which can raise FileNotFoundError / HomeInitializationError, so decompose_task (promises ok=False) and /api/local-models/status (garnish that must render degraded) would raise / 500 instead. The guard is restored at both sites with the same breadth the old code had.	2026-09-13 05:09:06 -07:00
teknium1	469a87f7a5	refactor(config): collapse thin _load_config copies onto the canonical readers ... doctor_live and kanban_decompose carried byte-identical `try: load_config() or {}` wrappers; local_models wrapped load_config in _quiet; each is now a direct load_config_readonly() call (read-only callers; the canonical already fails open and returns a mapping). Tests that patched the local wrappers patch hermes_cli.config.load_config_readonly instead. tools/code_execution_tool._load_config read the RAW file, so a managed-pinned `code_execution.mode` and the DEFAULT_CONFIG keys were invisible at tool discovery — it now reads load_config_readonly() (behavior change: the managed overlay applies to execute_code's mode/timeout). onboarding.mark_seen and credential_lifecycle's config mirror scrub parsed config.yaml with a bare safe_load; both are read→mutate→write round-trips and use read_user_config_raw, the documented write-back primitive.	2026-09-13 05:09:06 -07:00
Teknium	0f3199bd65	fix(dashboard): OAuth start routes resolve pollers late so test mocks intercept the spawned thread ... The oauth router imported _nous_poller/_minimax_poller/_xai_device_poller from web_server_oauth at module level, so tests patching the owning module ("hermes_cli.web_server_oauth._minimax_poller") patched a binding the router never read. The REAL poller then ran on the leaked daemon thread, called the live MiniMax token endpoint from CI, and the in-flight getaddrinfo segfaulted the interpreter during a later test's fixture setup (CI run 34323790818, tests/hermes_cli/test_web_oauth_dispatch.py flake). Route the three pollers through the existing late() seam (web_deps), the same mechanism every other monkeypatch-sensitive symbol in this router already uses, so the patch wins at thread-spawn time. Regression test proves the mock intercepts and the real poller body never runs; it fails on the old module-level import (sabotage-verified).	2026-09-12 21:00:55 -07:00
686f6c61	2bc9ed9f23	fix(mcp): fully redact credential headers in MCP probe errors and test display (salvage #97466) ... `hermes mcp test` resolved Authorization headers and printed first4***last4 — still a reusable credential fragment — and probe exceptions that echoed `Authorization: Bearer <value>` reached the CLI error line and the dashboard `POST /api/mcp/servers/{name}/test` response verbatim. Redact once at the `_probe_single_server` raise seam so every consumer (`mcp add`, `mcp test`, `mcp login`, `mcp configure`, the dashboard probe, `hermes doctor`, catalog probes) prints already-safe text. Recognized credential header fields (Authorization/Proxy-Authorization plus agent.redact._SECRET_HEADER_NAMES) have their complete value replaced with ***; bare Bearer/Basic/Token/Digest spans are covered; the generic redactor runs force=True as a second pass. CLI header display fails closed: only pure ${ENV} template values print. Salvaged from PR #97466 by @686f6c61 (base predated the mcp_config/web_routers decomposition; re-applied onto current main, test seams repointed to the defining modules tools.mcp_tool_loop / tools.mcp_tool_lifecycle). Inspired by Claude Code 2.1.268: "Fixed /mcp and /plugin server details, claude mcp list/get, and MCP login errors showing secrets resolved from ${VAR} placeholders in MCP configs." Fixes #97460 Co-authored-by: 686f6c61 <github@00b.tech>	2026-09-12 20:49:18 -07:00
teknium1	acbecf588a	fix(profiles): --clone leaves messaging channels behind; --clone-channels opts in ... A cloned profile carried the source's TELEGRAM_BOT_TOKEN, DISCORD_BOT_TOKEN, allowlists, WHATSAPP_ENABLED, API_SERVER_KEY and the platforms:/telegram:/ discord: config sections byte-for-byte. Standalone, that made two gateways fight over one bot's long-poll; under multiplex it blocked `hermes gateway migrate --multiplex` with one duplicate-credential finding per platform per clone (18 on a real 10-profile install). Every clone entry point (CLI --clone/--clone-from/--clone-all, dashboard POST /api/profiles, TUI/Desktop profiles.create incl. its mirror_credentials .env copy) now strips channel settings after the copy. The key set is derived from the adapters — Platform enum + plugin registry (required_env, allowed_users_env, allow_all_env, cron_deliver_env_var), the gateway env table (gateway.config_env._ENV_STEPS / _ENV_ENABLE_CREDENTIALS) and each platform's env prefix — so a new adapter is covered without a hand list. --clone-all also drops pairing/WhatsApp-session/gateway ledgers. Provider and tool keys, the model block, memory, skills and SOUL.md are untouched. `--clone-channels` (REST/RPC: clone_channels) keeps them; it is refused when a live multiplexer already serves the source and otherwise warns which platforms are now shared. `hermes profile list` prints the same warning for existing clones whose bot credential is byte-identical to the default's. The dashboard's per-platform env-prefix table moves into profile_channels so Channels-page cards and the clone stripper share one definition.	2026-09-12 18:35:21 -07:00
teknium1	6a66a5d481	fix(desktop,dashboard): served profile's api_server/webhook read connected with their /p/<profile>/ URL; shared-gateway restart asks first ... Under gateway.multiplex_profiles a secondary's api_server and webhook are never built as adapters (run_adapters skips SHARED_LISTENER_MIRROR_PLATFORMS: the default's listener answers /p/<profile>/...). The multiplexer record therefore has no `<profile>:api_server` entry, profile_platforms_from_multiplexer() returned {} for them and both /api/messaging/platforms and /api/status?profile= fell through to `pending_restart`: the Desktop Messaging card and Command Center said "Restart needed" forever for a platform that was answering. - gateway.status.shared_listener_mirror_platforms projects the default's LIVE api_server / webhook entry onto every served secondary with `ingress_url` = `<listener>/p/<profile>/v1` (`.../webhooks/<route>`); a dead default listener is not mirrored. The api_server / webhook adapters stamp the listener they actually bound (`listener_base`) on connect so the URL is the real one, not a config guess. `hermes status` lists those URLs beside the other shared-ingress platforms. - /api/status?profile= reports `gateway_shared_with` (every profile the multiplexer carries) when the served rung answered; null for a standalone gateway. - Desktop: the messaging card shows the URL line; "Restart gateway" from a served profile (statusbar menu, Cmd+K, messaging/webhooks banners, Command Center) confirms "Restart the shared gateway? All bots on this device reconnect: default, alpha, beta" (Restart all / Cancel) and toasts "Shared gateway restarted (3 bots)". Standalone keeps the silent path. - Dashboard: same confirm + toast on the System page and the sidebar restart; the 409 from start/stop on a served profile renders as an inline notice instead of a raw error toast.	2026-09-12 12:52:19 -07:00
teknium1	2d121aa322	fix(gateway): hot-serve reaches pooled Desktop backends; deleted profiles leave no stale runtime entries ... - PUT /api/messaging/platforms on a pooled `hermes --profile X serve` arrives without ?profile= (Desktop local topology, #109088): resolve the hot-serve target from the process's own profile so the multiplexer is pinged and the UI skips the restart banner. - A profile deleted while the reconcile lock was held by its own adapter connect was recorded back into served_profiles; re-check the live set before recording. - Drop a deleted profile's `<name>:<platform>` runtime-status entries instead of leaving them as `stopped`.	2026-09-12 08:49:16 -07:00
teknium1	d1dbb0ac9e	feat(gateway): multiplexer hot-serves profiles created while it runs, unroutes deleted ones ... A `gateway.multiplex_profiles` gateway enumerated `profiles/` once at boot, so a profile created afterwards (CLI, dashboard, Desktop, TUI) was never served until `hermes gateway restart`; Desktop and the dashboard gave no reminder, so a new profile's bot simply never connected. The served set is now reconciled at runtime (`gateway/run_profile_reconcile.py`): - `hermes_cli/profiles.py` create/delete ping the multiplexer over its control socket (new `rescan-profiles` verb); a supervised watcher rescans every 30s as the safety net. - A new profile gets its adapters under its own runtime scope from its config/.env (`_start_one_profile_adapters`, same duplicate-credential guard as boot, now seeded with the LIVE secondaries' claims), `served_profiles` in gateway_state.json is updated, MCP discovery + log routing run for it. Other profiles' adapters are never touched. - A served profile whose config.yaml/.env changed is re-scanned so a token added after create builds the adapter; already-live/queued platforms are skipped (no second poller). - A deleted profile (tombstone) has its reconnects cancelled, adapters torn down, pairing/busy bookkeeping and cached agents dropped, and this process's SQLite / memory-store handles released so the deleter's rmtree succeeds. - The in-process cron ticker takes a live enumerator so new profiles' jobs fire. - PUT /api/messaging/platforms/<id>?profile=X returns `hot_served` when a live multiplexer rebuilt X's adapters; Desktop/dashboard skip the restart banner then. - `hermes profile create` confirms hot-serve; the restart reminder stays for a gateway that did not pick the profile up (older build / signal failed).	2026-09-12 08:49:16 -07:00
Teknium	b0c383cdf7	fix(desktop): served profiles show running and route lifecycle to the multiplexer from a pooled local backend ... Electron sends a local sub-profile's REST to its pooled `hermes --profile X serve` without ?profile=; inside that process the unscoped branches never reached the multiplexer rung, so a profile served by the default multiplexer read as 'Messaging gateway stopped' on the system and messaging pages, start/stop spawned a child that exited 78 while the UI reported success, and restart ran `gateway restart` under X's HOME (same exit 78). Remote-backend topology was already correct because its requests carry ?profile=. Unscoped liveness/status/messaging now take the multiplexer rung for the process's own home; lifecycle verbs resolve the own profile, refuse start/stop with 409 and restart the multiplexer via -p default; Electron routes POST /api/gateway/{restart,start,stop} through the primary with ?profile= so the action lives on the backend the status poll asks and outside the pooled backend's shutdown SIGTERM.	2026-09-12 06:13:44 -07:00
Teknium	65fd3a2b9c	feat(status): show each served profile's shared-listener callback URLs ... hermes -p <name> gateway status, hermes gateway status and hermes status (under Serves:) list the /p/<profile>/<path> URL per inbound-port platform the live multiplexer serves, read from the <profile>:<platform> ingress_url in the default home's gateway_state.json (hermes_cli/gateway_multiplex_served.py). The dashboard's messaging payload carries the same ingress_url and the Channels page renders it. The dashboard's 409 guard now covers only api_server/webhook (the mirrored pair): enabling Twilio/LINE/Teams/... on a secondary is allowed because the gateway serves it.	2026-09-12 01:53:15 -07:00
Teknium	df95f378a6	feat(dashboard): "Migrate to a single multiplexed gateway" on the System page ... GET /api/gateway/migrate/plan returns the CLI plan JSON; POST /api/gateway/migrate spawns `hermes gateway migrate --multiplex --yes` detached (action log gateway-migrate.log). The Gateway card shows the button only for a multi-profile install that is not yet multiplexed, and disables it while listing the blockers.	2026-09-12 01:49:28 -07:00
Teknium	446f6f79a8	fix(multiplex): dashboard and gateway stop see a served profile's gateway as the multiplexer ... A profile served by the default multiplexer owns no gateway.pid / gateway_state.json, so every surface that reads per-profile identity files called it stopped while the CLI status surfaces (hermes -p X status / gateway status / cron status) said "running via the default-profile multiplexer": - `/api/status?profile=X` and `/api/messaging/platforms?profile=X` reported gateway_running=false / state=None / "gateway_stopped" in the same body that listed X under gateways[].served_profiles. The shared ladder `resolve_gateway_liveness` gains a fourth rung for a named profile_dir: the live default multiplexer that records X in served_profiles IS X's gateway (pid = multiplexer pid, runtime = its record, X's `<X>:<platform>` entries re-keyed to the standalone shape). - `POST /api/gateway/stop?profile=X` spawned `hermes -p X gateway stop`, which printed "No gateway running for this profile" (exit 0) into the action log while the UI flipped to stopped and the multiplexer kept serving X; `/api/gateway/restart?profile=X` spawned a `-p X gateway restart` that only exits 78. start/stop now answer 409 with the multiplexer explanation (one helper shared with the existing start refusal) and restart targets the multiplexer, the process that actually serves X. A `--force`-started separate gateway for X (own pid file) keeps normal per-profile management. - CLI `hermes -p X gateway stop` refuses with exit 78 like run/start/install/restart when X has no gateway of its own, instead of a contradictory exit-0 "not running". Docs: multi-profile-gateways.md §1 and §5 describe stop + the dashboard behaviour.	2026-09-11 19:38:36 -07:00
Teknium	f923faa0b8	feat(voice): GPT-Live voice chat mode — a full-duplex voice frontend that delegates to Hermes (Desktop) ... `voice.voice_chat_mode: gpt-live` swaps the desktop's chained STT → turn → TTS loop for OpenAI's gpt-live-1: one voice model that listens while it speaks and has no tools of its own. Every real request it hears becomes a normal Hermes turn on the open chat — any model/provider the session selected, full toolset, memory, approvals — and the voice paraphrases the reply aloud. Backend - tools/voice_live.py: mode/credential/persona resolution and the one server-side step the API needs — POST /v1/live/sessions exchanging the renderer's SDP offer, pinned to client delegation; the OpenAI key never reaches the renderer. Voice persona follows the vendor prompting guide (role, style, labelled delegation policy describing Hermes as the backend). VOICE_LIVE_TURN_NOTE is the per-turn model-input note (transcript in, speakable prose out). - REST: GET /api/audio/voice-live/status (mode + readiness, non-secret), POST /api/audio/voice-live/session (SDP exchange). The offer is passed byte-exact: a stripped trailing CRLF is a vendor 400 "unmarshal SDP: EOF". - prompt.submit accepts surface=voice-live (+ voice_context) beside hud; the note rides the model input via the existing _prepend_note seam, the persisted user row stays the user's words, the system prompt stays byte-stable. - config_defaults: voice.voice_chat_mode (chained|gpt-live), voice.gpt_live.*. Desktop - lib/voice-live.ts: RTCPeerConnection + oai-events data channel owner, transcript accumulation, session.commentary/thinking/instructions appends (500-token chunking), mute, graceful close waiting for session.closed. - hooks/use-voice-live-conversation.ts: same public shape as useVoiceConversation; delegation → prompt.submit(surface=voice-live); tool activity → quiet thinking appends; reply streamed back per sentence; spoken stop phrase ends the chat; a newer delegation interrupts an in-flight turn. - use-composer-voice mounts both engines and latches one at conversation start from the backend-resolved status; gpt-live without a key falls back to chained with a notice. Settings → Voice gets the mode dropdown, voice picker, persona. Live-verified on the worktree desktop build (headless Electron, CDP, synthetic mic): "what is 17 times 23 and which model are you on" → delegation → Hermes (Claude Sonnet 4.5 via OpenRouter) → spoken "391 … Claude Sonnet 4.5 through OpenRouter"; follow-up "double that" resolved from the spoken context → 782; "run uname -r" ran the terminal tool with "Hermes is working: terminal" fed as quiet context → spoken kernel version; "stop" closed the session (reason=close_requested). Chained mode creates no RTCPeerConnection.	2026-09-11 19:14:24 -07:00
Teknium	37dcc0a6e8	fix(gateway): a secondary API_SERVER_KEY no longer skips the profile; start/install/status honour the live multiplexer ... Under gateway.multiplex_profiles the default gateway serves every profile, yet four startup/status paths still reasoned from the wrong source: * A secondary profile's API_SERVER_KEY (which the docs REQUIRE for /p/<profile>/ auth) auto-enabled api_server in that profile's config, so _load_secondary_profile_config raised SecondaryPortBindingConfigError and the whole profile was skipped. gateway/config_env.py::_enable_from_env now leaves `enabled` alone for port-binding platforms while a multiplexer loads a NON-default profile (home override + multiplex flag, the same signal gateway.config uses for scoped reads); the credential still lands in extra so the shared listener can authenticate the prefix. Default profile unchanged. * "Is this profile served?" was re-derived from the default config.yaml plus GATEWAY_MULTIPLEX_PROFILES as seen by the CLI process. `hermes -p coder ...` loads coder's .env, so an env-only opt-in on the default profile was invisible (guard never fired, status said stopped) and an allowlist edit flipped the answer before the restart. named_profile_served_by_running_multiplexer now reads the pid-verified default gateway_state.json served_profiles (written by _record_served_profiles) first and falls back to config derivation only when the key is absent. The record helpers live in hermes_cli/gateway_multiplex_served.py. * The served-profile guard ran only inside `gateway run`. `hermes -p X gateway start|install|restart` reached the service manager, whose unit then exited 78 forever (systemd parks it while the CLI prints "started"; launchd KeepAlive respawns every 30 s). The service verbs now run the same guard up front (exit 78, same message) and accept --force; the Desktop /api/gateway/start route returns 409 for a served profile instead of spawning a doomed child. * Status surfaces disagreed: `hermes -p coder status` said stopped, `hermes -p coder cron status` said "cron jobs will NOT fire" while `cron list` said fine, and the default `hermes status` never listed served profiles. Both now route through the probe / the recorded served set. The -p/--profile matcher in _scan_gateway_pids and gateway.status._command_line_belongs_to_profile compares the flag token for equality (`-p ops` no longer claims -- or lets `gateway stop` SIGTERM -- an `-p ops-2` gateway). Docs: multi-profile-gateways.md now describes the start/install refusal, the --force flags, the API_SERVER_KEY behaviour and the single default-home gateway_state.json (the per-profile runtime_status.json claim was wrong). Fixes #100397 Addresses #89726 #97360 #71344 (cherry picked from commit d002c1864a7b6a22c53758b16b7b0cc79aea2edf)	2026-09-11 15:27:23 -07:00
Teknium	0dcadf6f41	revert: remove Collective Wisdom V1 (#94266) ... Reverts the in-tree org skill-marketplace: hermes_wisdom package, three model tools, CLI/gateway/desktop/dashboard/Telegram/Slack surfaces. Later non-Wisdom work on shared files (guest onboarding i18n, dashboard startup schema, Slack adapter, tui_gateway) is kept; Wisdom-only call sites and config were stripped from those files.	2026-09-11 11:54:49 -07:00
emozilla	5764ae3168	fix(local-models): keep automatic recommendations GPU-resident ... Stop recommending a system-RAM spill when no curated model fits resident. Preserve explicit model selection and the existing resident quality/speed ranking, including the separate unified-memory policy. Require a recommendation for automatic quickstart, expose Browse when none exists, and rename Configure to Let me choose. Keep policy copy and reason keys consistent across the four translated local-model sections. Cover automatic refusal and explicit spilled setup against one budget, plus the Browse, Download and Use interactions in the desktop pane.	2026-09-11 12:43:21 -04:00
Teknium	fdd32f81d4	fix(web): report a corrupt state.db as a throttled 503 status instead of a traceback per poll ... The dashboard polls /api/analytics/usage and /api/analytics/models every few seconds. When state.db is malformed the read raised straight through the handler, so uvicorn logged a full traceback at ERROR on every poll — one fleet host wrote ~520K identical journal entries in 24 h. Wrap both analytics handlers in `corrupt_store_as_status`: a corrupt-image sqlite3.DatabaseError (is_malformed_db_error) becomes a 503 with an explicit `state_db_corrupt` payload pointing at `hermes doctor`, and the warning is gated per store path via `{path: monotonic}` (>=300 s), then debug. Busy/locked and every other error propagate unchanged, and the file is never renamed or quarantined from the dashboard — repair stays with `hermes doctor` / `hermes sessions repair`. `_session_db_path_for_profile` is split out of `_open_session_db_for_profile` so the router can name the store without opening it. Refs #96591 Reported-by: #96591	2026-09-11 06:37:27 -07:00
Siddharth Balyan	0e927c914d	Guided first launch behind HERMES_GUEST_ONBOARDING: intro, guided chat, first task in default (NS-848, PR B1) (#107958) ... * feat(desktop): port guided onboarding substrate Add seeded session creation, transcript directives, profile routing, and the shared window and pane primitives needed by the guided flow. Keep later-step mounts deferred and exclude provider selection and retry machinery. * refactor(desktop): anti-slop cleanup for substrate Assemble seed parameters in the existing create helper and use the owning transcript attribute type. Read the guaranteed gateway and connection contracts directly to remove runtime type probes and unchecked assertions. * test(desktop): create-overrides invariants Verify that reasoning and title overrides do not select a provider or model. Empty overrides and seeds add no parameters. * feat(desktop): port first-run cinematic window Play the cinematic behind the guest onboarding launch flag using bundled Collapse and JetBrains Mono. Give the native window its own controller and restore the app on skip, renderer deadman or native watchdog. Drop the perf scenario because it depends on the removed replay hook. Guided chat kickoff and app-shell gate wiring remain with their later steps. * refactor(desktop): anti-slop cleanup for cinematic Preserve audio and canvas behavior through named types and inferred results. Split the viewport node and frame drawing to keep control flow bounded. Cut comments that only repeat the code. * feat(desktop): add onboarding gate and answers stores Track cinematic, guided chat, handoff and completion in one phase record. Queue the guide after the intro and share pending kickoff work between callers. Keep existing saved answers while dropping retired preferences. Leave intro seen-state ownership with the cinematic store. * feat(desktop): port guided onboarding chat Add guided setup cards, runbooks, machine context, and onboarding presence. Connect transcript rendering and first-build progress to the desktop behind the onboarding flag. Leave session kickoff and handoff execution for the next step. * refactor(desktop): anti-slop cleanup for guided chat Keep directive and layout lookups typed. Remove unsafe test casts and isolate onboarding transcript calculations without changing the flow. * feat(desktop): connect guided onboarding to durable first-build handoff Start the guide only after its profile backend confirms bootstrap readiness. Seed or adopt the welcome chat, then transfer the first build to default with a durable receipt and explicit retry. Wire cinematic completion, screen stand-down, layout growth and progress check-ins. Save agreed preferences before creating the build and release prompt slots after storage refusal. * refactor(desktop): anti-slop cleanup for onboarding handoff Reuse the gateway request and error contracts. Isolate guide adoption and snapshot validation while preserving receipt recovery and reasoning overrides. Validate persisted receipt fields at the JSON boundary without coercion. Keep corrupt identities rejected and retain only the permitted test mocks. * fix(desktop): guided chat review fixes Wire the native machine probe so guided setup can suggest a name and offer the right first task. Restore the comments that explain the flow boundaries. The directive registration uses the launch flag to preserve ordinary chat. Ruling 6 folds active.ts into assembly to keep activity ownership together and removes the second greeting source so the seeded and visible greetings agree. * fix(desktop): handoff review fixes Probe the guide backend before switching profiles so a readiness refusal keeps classic onboarding on the current backend. Restore list-valued personalization coverage and routing rationale. Remove the obsolete setup status fixture. * chore(desktop): onboarding script cull and rehearsal recipe Document a temporary-state rehearsal using the existing onboarding flag and optional portal stand-in. Keep the main scripts unchanged and retain window growth for the guided chat. * fix(connectors): reject incomplete catalog responses * feat(gateway): scope connector controls to the owning session * feat(desktop): connect apps through native session-owned controls * feat(desktop): gate connector cards and enable free-tier access Use the launch flag before mounting connector controls so classic transcripts add no status requests. Allow existing free-tier identities through the read-only tool gateway gate and test the owning-profile RPC path with A’s launch gate. Keep authorization links out of previews. * style(desktop): format connector translations Apply Prettier to the connector copy blocks while preserving upstream translations and free-tier wording. * refactor(desktop): anti-slop cleanup for connector card Use the transcript JSON contract and concrete RPC parameters. Preserve malformed-value filtering at one string boundary and make the fixture and row types explicit. Keep connector execution and cancellation behavior unchanged. * feat(desktop): detect initial language from the OS Use the native machine locale when no supported language is saved. Preserve explicit choices and leave inferred languages out of config. * refactor(desktop): anti-slop cleanup for initial locale detection Keep unvalidated config values at the existing validation boundary. Pass no saved choice after that boundary has ruled it out, preserving locale precedence. * test(desktop): onboarding port test set Make native window tests reject duplicate IPC handlers and isolate disabled onboarding. Assert the active gate mock when onboarding re-enables. Keep the test set limited to behavior carried by the port. * fix(desktop): recover failed guide kickoff and reveal once The review found that a failed guide create stranded the solo shell and draft profile, and solo boot faded an already visible window a second time. Restore the prior route and layout, release onboarding through its existing phase record, and surface create failures. Let the film own the reveal while solo boot animates the visible resize. * fix(desktop): preserve transcript ownership across cards and handoff The review reproduced answers submitted to the focused chat, repeated questions disabled across sessions, handoff recovery using foreground identity, and mount-dependent progress history. Target each card’s own composer, scope settlement to its message and session, carry the issuing guide through handoff, and derive progress from its transcript with streaming activity. Reuse the existing owner ladder for exact and profile-only routes. * fix(gateway): preserve connector ownership with profile routing The review found that shared-primary profile metadata was rejected before connector dispatch, while desktop controls treated a missing registry id as missing ownership. Accept profile only as routing metadata and keep the live transport as authorization. Resolve card ownership through the existing exact/profile ladder, retaining ambient routing only for the single-backend case. * fix(desktop): resolve plugin roots and gate the Basic layout The review found that the first plugin build was seeded with a different installation’s fixed path, and the director ruled that flag-off layouts must match main. Resolve the running desktop’s plugin root before seeding a plugin build and register Basic only when onboarding is enabled. Keep the runbook wording and the ordinary four layout presets intact. * fix(desktop): clear review-fix slop findings The slop gate flagged an undocumented layout-data assertion and unknown-return types in the new test selectors. Record the layout registry invariant and preserve each selector’s return type. The only remaining production finding is the accepted connector-tools baseline. * fix(desktop): detect the OS language on a fresh install The review found that the merged English config default prevented the desktop from probing the OS language on a fresh install. Add an opt-in saved-values read so an absent choice remains distinct from saved English. Preserve default-valued English only for explicit language saves; unrelated settings saves must not turn a merged default into a language choice. Older backends ignore the new query options and keep returning merged English, preserving their existing desktop behavior. * test(desktop): make the flag-off layout registry test deterministic The flag-off test awaited the full controller import, pulling in the UI graph and installing application watchers just to read layout presets. That import took 9.5 seconds locally and timed out in the director's run. Move the existing trees and registration into a small layout-presets module. Production and the synchronous test use the same flag-gated registration, without starting the controller in the test. Keep the real registry invariant and dispose the test's contributions after completion. * fix(desktop): keep the transcript parser and ::ask behind the onboarding flag Register the guided chat's question card only with onboarding enabled. Restore main's whole-paragraph parser and contribution rendering when the flag is off, including its streaming prose behavior. Keep segmentation for the guided flow until B4 decides the parser's wider use. Restore main's two parser test files so its existing product and plugin contracts remain the flag-off check. * test: drop the onboarding and connector tests pending a later ticket Apply the director's ruling to remove B1's added test files and restore main's existing suites. Keep only the gateway route-reader mock contract that main's profile tests need against the shipped activation behavior; their cases and assertions stay intact. The flow's shape is not settled and B3/B4 rewrite it. The connector layer will also be reworked. The live CDP run is the flow check until a follow-up ticket brings tests back. --------- Co-authored-by: brooklyn! <brooklyn.bb.nicholson@gmail.com>	2026-09-11 15:45:43 +05:30
shannonsands	a6ee31f55a	feat(wisdom): add Hermes Collective Wisdom Agent V1 (#94266) ... * feat(wisdom): add trusted publish and install foundation * feat(wisdom): add private contribution loop * feat(wisdom): add managed consumption workflows * fix(wisdom): close cross-repository safety gaps * fix(wisdom): align local package and lifecycle policy * fix(wisdom): require explicit profile setup * docs(wisdom): repin reconciled gateway head * fix(wisdom): fence content downloads and approval receipts * docs(wisdom): record generation-fenced downloads * docs(wisdom): record unified delivery PR * fix(ci): stop passing invalid classifier inputs * docs(wisdom): remove internal requirements ledger * feat(wisdom): localize dashboard and desktop copy * feat(wisdom): complete local contribution and consumption UX * style(wisdom): satisfy desktop lint * chore(wisdom): refresh requirements pin * test(dashboard): allow formatted profile copy * test(wisdom): stabilize desktop interaction coverage * fix(wisdom): surface dashboard action failures * fix(wisdom): add repeatable Portal demo login * feat(wisdom): add actionable skill notifications * feat(wisdom): add notification install and update actions * fix(wisdom): make Telegram skill alerts actionable * fix(wisdom): always refresh demo Agent login * feat(wisdom): embed Telegram notification actions * fix(wisdom): preserve Telegram notifications after actions * fix(wisdom): keep Telegram notification cards readable * feat(wisdom): add Telegram candidate approval flow * feat(wisdom): explain Telegram qualification reasons * fix(wisdom): reconcile cross-surface candidate actions * feat(telegram): add Collective Wisdom management command * chore(wisdom): refresh Gateway contract pin * chore(wisdom): advance Gateway contract pin * feat(wisdom): align command UX across clients * feat(slack): add Collective Wisdom management parity * feat(wisdom): add security and professionalism reviews * feat(wisdom): add first-time qualification guidance * feat(wisdom): simplify qualification sharing choices * feat(skills): add optional editorial metadata * feat(wisdom): enrich legacy skill presentation * fix(wisdom): harden review and update boundaries * fix(wisdom): emit canonical review timestamps * fix(wisdom): align with merged gateway and main * wisdom: add agent-led sharing core (policy, evidence, schemas, templates, delivery, weekly job, share/install flows) - hermes_wisdom/agent_led/: policy resolution (server > local > defaults), 7-day evidence builder that excludes bundled/hub/managed skills and dismissed/handled/recently-suggested content hashes, strict pydantic schemas for agent output with repair-or-reject, fixed copy templates (Share / Teammate / Published / Update / Mute), idempotent retried delivery ledger with stale-action resolution, weekly review job, resumable Share and Install flows. - prompts/: candidate review, recipient recommendation, share packaging. - tests/wisdom/test_agent_led.py: 30 tests. * wisdom: agent-led renderers and button action dispatcher - render.py: Telegram HTML, Slack blocks, Desktop payload; editorial name is the emphasized line, product label stays separate. - actions.py: resolve opaque wa:<action>:<dedup> targets via the delivery ledger; Not now -> dismissal, Mute -> fixed options, Share -> resumable packaging flow, Install/Update -> plan command. Never publishes/installs. * wisdom: CLI verbs, agent_led config default, conversational catalog skill - hermes wisdom browse/review-week/act/share/dismiss/mute (all --json). - wisdom.agent_led config block, default enabled. - SKILL.md rewritten so natural-language catalog questions map to the CLI verbs, share/install flows and fixed notification templates. * wisdom: wire agent-led weekly review into gateway tick and Telegram buttons - gateway housekeeping tick calls maybe_run_weekly_review with a home channel sender when a Telegram adapter is available. - Telegram: wa: callbacks resolved through the ledger (stale-safe), mute duration keyboard, send_wisdom_agent_recommendation rich card + fallback. * fix(wisdom): integrate local mediation and harden model and setup boundaries * fix(wisdom): honor authoritative recommendation policy and defer on failure * fix(wisdom): synchronize opaque suppression and recheck delivery preferences * feat(wisdom): route weekly selection through the session-owned assessment queue * fix(wisdom): prepare and submit the reviewed generated share package * feat(wisdom): separate native Share preparation from publication consent * feat(wisdom): sync native mute choices through a leased preference outbox * feat(wisdom): bind native mute controls to durable preference choices * feat(wisdom): add scoped desktop and dashboard notification settings * fix(wisdom): revalidate feed recommendations before assessment and delivery * fix(wisdom): persist validated delivery receipts before completing notices * feat(wisdom): add private notification claim and receipt client * Persist Wisdom send reservations and recover delivery acknowledgements * Route legacy Wisdom controls through current native review * Add typed private Wisdom operation outcome client * fix(wisdom): make agent-led advice usable in the local demo * fix(wisdom): keep requested consent outside proactive limits * fix(wisdom): distinguish unavailable assessments and preserve digest text * fix(wisdom): assess ongoing usefulness beyond the current task * fix(wisdom): restore immediate qualification sharing controls * fix(wisdom): separate qualification review from installation advice * fix(wisdom): collapse review checklists and simplify sharing copy * fix(wisdom): show compact sharing progress and publication receipts * fix(wisdom): require credential prefixes rather than matching skill names * fix(wisdom): finish package checks before presenting sharing consent * fix(wisdom): scan local skills before qualification cards * fix(wisdom): update moderation results on existing sharing cards * fix(wisdom): keep sharing review accessible from receipt cards * fix(wisdom): align mediated review cards and collapsible checks * fix(wisdom): clarify clean security summary wording * fix(wisdom): normalize consent plans and add explicit recheck * fix(wisdom): keep install and update receipts concise * fix(wisdom): collapse assessments and deduplicate operation cards * fix(wisdom): restore private Portal review from native cards * fix(wisdom): sync Portal publication to original consent card * fix(wisdom): show local skill version on sharing cards * fix(wisdom): skip agent recommendations for self-published versions * fix(wisdom): simplify candidate notices and local-edit recovery copy * feat(wisdom): submit locally reviewed packages with one confirmation * feat(wisdom): expose safe receipt and outcome sync recovery * wisdom: onboarding notice says detect and share, names the user's own skill Copy review from the product owner on the first and returning qualification notices (fixed delivery mode): - the feature blurb now says the org enabled detection *and sharing* - both notices say the detected skill is one the user created - both close with an exclamation mark Applied identically to hermes_wisdom.notice, the desktop and web i18n strings, and the tests that assert the sentences. * wisdom: one opener, no approval line, ask to share after the skill is shown Product owner review of the candidate card. - The Hermes written card now opens with the same sentence as the fixed card ("Your organisation has enabled Collective Wisdom, a feature designed to automatically detect and share useful skills across all team members.") instead of its own blurb, so there is one first time message. - "Nothing is shared without your approval." removed from Telegram, Slack and Desktop. The buttons already make the permission explicit. - "Would you like to share?" no longer appears before the skill is named. It is now the last line, after the skill name, description, why suggested and the checks, and reads "Would you like to share it?" (matching the agent led template wording). Tests updated for the new order; proposalNotice removed from all desktop locales. * wisdom: American spelling, organization Product owner decision: user facing copy uses American spelling. Changes "Your organisation" to "Your organization" in the chat notice, the Hermes written card opener, the desktop and web strings, and the tests that assert them. Identifiers such as nas_organisation:* and the German and French locales are untouched. * wisdom: candidate card copy round 4 (owner review) Apply the product owner's round 4 copy decisions to the Hermes Collective Wisdom candidate card on Telegram, Slack, Desktop and the shared views: 1. Hermes-written cards are titled "Hermes Collective Wisdom" instead of the bare "Collective Wisdom". 2. The "Reusable skill ready to review" line is gone from the candidate card (Telegram rich card and plain fallback, legacy agent-led share template). 3. The skill name and description are labelled: "Skill name: <name>" and "What it does: <description>" (Telegram, Slack, Desktop). 4. "Why suggested:" is now "Why others might benefit:". 5. A passing professionalism review reads "Safe to share at work ✓ (no inappropriate content found)" with no per-check bullets and no "Pass"; a failed review reads "Needs a look before sharing at work (possible inappropriate content)" and lists only the checks that flagged something. Pending/unavailable wording is unchanged. 6. Telegram button toasts: "Will ask later...", "Preparing more details...", "Sharing...". 7. Qualification reasons: "You used this skill consistently across many days." and "You've really refined this skill." 8. prompts/wisdom_candidate_review.md asks for a compelling editorial_name, a simple one_line_description and a compelling why_coworkers_benefit under 300 characters; "Be concise and convincing." becomes "Be concise and compelling: the goal is that the user wants to share it." Tests updated for the new strings; review_text() gains direct coverage. * wisdom: re-apply owner copy after rebase - Native share cards (advice_view/interaction_view): drop the approval line, ask "Would you like to share it?" as the last line after the checks - Hermes-written completion card titled "Hermes Collective Wisdom" - Qualification reasons use the owner wording (consistently across many days / really refined) - American spelling (organization) in remaining English copy - Desktop test asserts the current Share button; web test matches the returning notice * fix(wisdom): pin reconciled Gateway and verify Unicode hash vectors Pin Gateway 60cd2d6b613ae3cd4a6e65155d1142006d907e78 and byte-identical producer artifacts. Verify every content-order case and package-manifest binding. Validation: 186 focused Python tests, Ruff and contract verifier. * fix(wisdom): reconcile optional SDK tests and frontend lint * fix(wisdom): default to agent-written notification summaries * fix(wisdom): restore deferred install review and browse controls * feat(wisdom): inspect installed setup with exact package provenance * feat(wisdom): run native-approved installed setup steps with durable evidence * fix(wisdom): recover interrupted setup with explicit native consent * feat(wisdom): hand native installs into guided setup review * fix(wisdom): continue requested setup with fixed notification copy * fix(wisdom): preserve setup while waiting for a session model * fix(wisdom): expose canonical setup review controls on desktop * fix(wisdom): resume setup after recorded automatic updates * fix(wisdom): make missing setup prerequisites recheckable * chore(wisdom): align Agent with verified Gateway contract * fix(wisdom): stop guessing team slugs in portal links * fix(wisdom): retire pending advice on account sign-out * fix(wisdom): cancel advice after terminal account revocation * fix(wisdom): fence feed responses across account sign-out * fix(wisdom): checkpoint signed-out feed before reactivation * fix(wisdom): link proactive advice to scoped notification settings * fix(wisdom): coalesce queued publication recommendations by version * fix(wisdom): keep package review navigation local and deferable * fix(wisdom): reflect installed state in discovery controls * fix(wisdom): show exact checks before command confirmation * chore(wisdom): pin bounded analytics privacy contract * chore(wisdom): pin retired legacy notification contract * feat(wisdom): review publisher usage with exact sharing copy * fix(wisdom): align discovery and review check summaries * fix(wisdom): show expired consent before confirmation * fix(wisdom): require fresh review for legacy install controls * fix(wisdom): preserve review expiry across check toggles * fix(wisdom): retain update policy in native install reviews * fix(wisdom): surface failed native card edits * fix(wisdom): persist local command approval reviews * fix(wisdom): use saved approvals for messaging commands * test(wisdom): provide scan result in setup handoff fixture * test(wisdom): exercise Telegram approvals with saved review state * fix(wisdom): retain suppression policy for offline deferral * fix(wisdom): reconsider candidates after deferred suppression expires * fix(wisdom): bind review checks and report verified readiness separately * fix(wisdom): persist accepted publication intent and recover exact outcomes * fix(sync): pin UTF-8 tree ordering across writers * chore(wisdom): pin organisation-scoped Gateway authorization * fix(wisdom): restrict consent delivery to user-facing sessions * chore(wisdom): refresh reviewed Gateway contract pin * fix(wisdom): preserve kept tools in Blank Slate exclusions * test(auth): reset anonymous fixture with a profile-scoped cache * fix(wisdom): gate local surfaces and work on current profile entitlement * fix(wisdom): invalidate quiet tool cache on entitlement changes * test(wisdom): authorize local consent gateway fixtures * fix(wisdom): keep entitlement decoding free of native crypto imports * test(wisdom): provide local entitlement to demo CLI subprocess * ci: leave upstream workflow unchanged in Wisdom PR * fix(wisdom): ship package and contracts in Nix wheels --------- Co-authored-by: hbizi <36184542+hbizi@users.noreply.github.com>	2026-09-11 19:04:06 +10:00
kshitijk4poor	c2d01f1012	fix(desktop): key the page under the stamp its rows already carry ... A custom HERMES_HOME (outside the profiles tree) reported `profile: null`, so the tail entry landed under profile '' while the session's owner hint — built from list rows that _serving_profile() stamps "default" — looked up 'default'. Two identities for one backend; the exact-key lookup missed and "Show earlier" stayed hidden for the Desktop's own sandboxed and HERMES_HOME-overridden installs (electron/main.ts resolveHermesHome). The messages endpoint now returns the same _serving_profile() stamp the list rows carry, so the Desktop keys a page under the owner it already routes the session by; the inline resolver and its function-body import go away. On the renderer, the ambient profile used for backends that predate the field is captured at request time alongside the connection, so a profile switch mid-read cannot re-key the page.	2026-09-11 13:08:19 +05:30
Robin Fernandes	d45842d206	fix(desktop): preserve older history pagination across scopes	2026-09-11 13:08:19 +05:30
Jeffrey Quesnelle	8d79c2ff57	Merge pull request #107959 from NousResearch/fix/local-fit-mtp-accounting ... fix(local-runtime): unify memory accounting and effective-window MTP	2026-09-11 02:05:40 -04:00
emozilla	0316d3d404	fix(local-runtime): unify memory accounting and effective-window MTP ... Price weights, context, runtime, projector and batch overhead consistently across catalog admission, initial launch, growth and restored windows. Keep MTP and the larger window when lean batches avoid unnecessary spill. Admit optional external drafts only when their complete footprint fits. Use preset-only model discovery so refused files cannot autoload, and preserve refusal/spill decisions atomically for desktop status read-back. Add regression coverage for complete-footprint boundaries, MTP restarts, growth admission, draft budgets and placement status transitions. Builds on the overhead-accounting contribution in #102993 and the restored-window MTP contribution in #106897. Does not adopt the 40% host-RAM reserve or resolve the remaining requests in #102865/#106895. Co-authored-by: infinitycrew39 <infinitycrew39@gmail.com> Co-authored-by: KoNit-K <124019182+KoNit-K@users.noreply.github.com>	2026-09-11 01:40:43 -04:00
Teknium	338bf9ea9a	fix(cli): banner/TUI/dashboard update checks go through the GitHub API, cached 24h ... The Python passive check (`banner.check_for_updates`, used by the CLI banner, `hermes --tui`, every `tui_gateway` spawn and the dashboard's /api/hermes/update/check) also ran `git fetch origin main` on every cache miss, and never cached an inconclusive result so a flaky line retried on every start. Same GitHub complaint, same fix: - remote tip via GET /repos/{slug}/commits/main (vnd.github.sha), local tip via rev-parse, exact count + changelog via the compare API when they differ. HTTPS `ls-remote` remains only as the fallback when the API is unreachable or the origin isn't on GitHub. - cache TTL 6h -> 24h, failures cached 1h; the cache is keyed on HEAD so `hermes update` invalidates it immediately. - the dashboard's "what's changed" list comes from the memoized compare payload (`upstream_commits_behind`) instead of `git log HEAD..origin/main`, which was stale without a fetch. Tests rewritten to the new contract: passive checks must not run `git fetch`/`ls-remote` for a GitHub origin; the daily cache invalidates when HEAD moves and re-asks after the failure window.	2026-09-10 18:15:54 -07:00
Siddharth Balyan	cbcf7b72f7	feat(gateway): sign in with a Nous account from a chat (/login), one shared sign-in flow (#105261) ... * refactor(auth): one sign-in flow behind SignInState, rendered by the CLI and the desktop * feat(gateway): /signin signs the free tier into a Nous account from a DM * feat(cli): chat surfaces name /signin as the sign-in verb * fix(auth): review follow-ups for the shared sign-in flow and /signin * fix(i18n): carry the /status free-tier line in every locale catalog * refactor(cli): the chat sign-in command is /login * fix(auth): durable override cleanup in the /login sweep, and the sign-in flow in its own modules	2026-09-11 03:45:33 +05:30
Siddharth Balyan	3b01b4ce0f	feat(desktop): Nous free tier on Hermes Desktop (#105260) ... * feat(desktop): free-tier state over RPC, status routes that name it, and a sign-in that keeps connectors The desktop learns about the Nous free tier by reading local auth state (pull): free_tier.status answers has_guest / enabled / carries_inference / notice_pending with zero network, and free_tier.ack_notice persists the one-time notice flag on the identity itself. setup.runtime_check reports free_tier for the selected route; /api/portal, the Nous card in /api/providers/oauth and billing.state carry free_tier (billing answers the free tier locally instead of a portal call that can only fail). The free-tier picker row carries an explicit free_tier_row flag and is never priced or locked. POST /api/providers/oauth/nous/start over a free-tier identity registers the connector transfer and returns its code and consent URL; the poller waits for the transfer before the token grant, persists the account, runs settle_after_upgrade, and the poll response gains reason, account_email and model. * feat(desktop): free tier on Hermes Desktop: ready screen, notice strip, status chip, Billing view, one sign-in dialog The renderer reads the free tier from free_tier.status (pull) into one store; the first-launch intro is the same state rendered two ways, keyed on the backend's one-time flag: the onboarding overlay opens on a ready screen when the free tier carries inference, else a one-time strip above the composer. Settings > Billing gains a free_tier view (notice with one Sign in, Plan / Model / Connectors summary, plan card, footnote; no payment or usage rows). A status-bar chip names the tier and model while it carries inference. Every entry point opens one claimed sign-in dialog that drives the extended oauth/nous route and maps the poll's status and reason to the ruled screens; Done settles billing, model options, providers and re-homes a session still on nous/welcome. The picker badge also fires on free_tier_row. Docs: Desktop section in the free-tier guide, AGENTS notes. * fix(desktop): free_tier.status starts the free tier's background setup when no identity exists A served backend has no session-setup moment like the CLI's, so beside an explicit provider the free tier was never set up on the desktop: no connectors, no notice strip. The first status read now starts the same one-attempt background setup; the call itself never waits. * fix(desktop): one Sign in on the Billing page; Settings > Providers names the free tier, never Connected The free-tier plan card is the what-you-get text alone (the notice carries the page's one Sign in). The Nous provider row reads Nous · free tier with a Free tier tag while the identity is the free tier, instead of Nous Portal · Connected. * fix(desktop): Settings > Providers never files the free tier under Connected * fix(desktop): the intro's shape is keyed on the route, not on the identity free_tier.status reports available (an identity exists and the tier is on); whether inference runs on the free tier is setup.runtime_check.free_tier, keyed on the resolved endpoint. The ready screen shows when that route is the free tier; the composer strip when the user's own provider carries inference. An own-key install used to get the ready screen. * docs(desktop): say what the free-tier chip is keyed on * fix(desktop): the featured Nous row's pitch on the free tier says what signing in adds * fix(desktop): a cancelled or superseded sign-in attempt can no longer change the identity or hide the intro Four lifecycle holes from review. The Nous poller checks the session's cancelled flag after the transfer wait, after the token grant, and once more under the session lock together with the save, so a sign-in the user abandoned never persists. The renderer's sign-in store carries an attempt generation that every continuation checks after each await, so a poll from a closed attempt cannot publish over the one on screen (and its backend session is cancelled). The ready screen comes down only after the backend recorded the acknowledgement. A composer still mounted takes over the notice claim when its owner unmounts. One thin test per hole.	2026-09-11 03:45:32 +05:30
Siddharth Balyan	04a76c4109	fix(auth): a sign-in from the free tier settles the default model and route (#105259) ... * fix(auth): a sign-in from the free tier settles the default model and route once, for every caller Picking the free-tier row leaves model.default at nous/welcome pinned to the welcome host. After a sign-in an account cannot keep either: the welcome host refuses account tokens, and the portal host serves nous/welcome as a paid model. One completion step, anon_auth.settle_after_upgrade, now runs after the account is persisted: a config on the free tier's route moves to the account's inference host and the recommended default for the account's plan, through the same config write a plain Nous login uses; a config on the user's own model is left alone. The pick is the one GET /api/model/recommended-default already makes, factored into models.recommended_nous_default_model so the CLI and the desktop land on the same model. hermes auth upgrade prints the new default. * fix(auth): a sign-in completion with no eligible recommendation leaves no default model The static provider-wide default is not narrowed by the account's plan or org policy, so writing it as a fallback could persist a model the account may not use. When the recommendation cannot yield a model, the route still moves to the account's host but model.default is left unset; the CLI says so and points at `hermes model`. * docs(free-tier): say what happens when no recommendation is available after sign-in * fix(auth): sign-in completion moves the host and clears the default in one config write Two writes could fail between them and leave the account host paired with nous/welcome. _update_config_for_provider gains clear_default so the caller with no model to offer removes model.default in the same atomic write that sets the host.	2026-09-11 03:45:31 +05:30
Teknium	6d89c1afde	feat(plugins): pin a plugin to a commit from Desktop, and show pins in every list ... Only the CLI could install a plugin at an exact commit (`--ref <sha>`); the Desktop "Install from Git" dialog, the TUI gateway `plugins.manage install` method and the dashboard `/agent-plugins/install` endpoint all called `_install_plugin_core` without a ref, so a team that wanted everyone on the same private-plugin commit had to leave the app for a terminal. - `dashboard_install_plugin(ref=)` threads the pin to `_install_plugin_core`; the 40-hex validation and HEAD verification are unchanged. The gateway method and dashboard body accept `ref`. - Desktop dialog gains an optional "Pin to commit" field (custom sources only, client-side 40-hex check disables Install on anything shorter). - `plugins.manage list` rows carry `pinned_sha`; the Desktop plugins tab shows a `pinned @ <sha8>` badge and `hermes plugins list` prints `git pinned@<sha8>` in Source, so a team can eyeball that everyone runs the same commit.	2026-09-10 05:09:15 -07:00
Teknium	e1f1c8a935	fix(dashboard): stopped gateway no longer reports a dead process's platform error ... gateway_state.json preserves per-platform entries across restarts, so a gateway that once ran without TELEGRAM_BOT_TOKEN and then stopped kept reporting 'fatal / No bot token configured' on the Channels/Messaging pages even after the user saved a token — the Desktop showed 'Saved' on both fields next to the error. Only a live gateway's verdict describes current config; when no gateway is running the platform reads gateway_stopped with no error.	2026-09-10 02:48:21 -07:00
Teknium	ac087e6ada	fix(console): cancel/timeout interrupts the command's agent and waits for the worker ... Hermes Console ran each command on a ThreadPoolExecutor and cancelled only the asyncio waiter. A command that forks an AIAgent (`curator run --consolidate`) kept its worker thread and its in-flight provider request alive after the prompt said "cancelled" — a llama.cpp generation kept decoding for 30+ minutes and held the inference slot (#106179). Root cause: the host owning the thread never knew about the agent created deep inside the synchronous command, so it could not call the existing cooperative `interrupt()` path that closes the request sockets. Fix: `agent/interrupt_scope.py` gives the host an `InterruptScope`; the console binds it around the worker (ContextVar), and every `AIAgent.run_conversation()` registers itself with the bound scope for the turn. On cancel, timeout and disconnect the console calls `scope.cancel()` (hard-interrupts every registered agent; an agent registering after the cancel is interrupted on entry so the cancel cannot lose the race with a turn that has not started) and awaits the worker Future with a 10s bound before reporting cancelled/timeout. Queued-but-unstarted work is dropped via `Future.cancel()` alone. Live repro (fake OpenAI-compatible provider blocking like llama.cpp, real /api/console, real curator dispatch, real AIAgent + direct request path): origin/main at the "cancelled" frame -> request_exited=false, worker_exited=false; with this change -> both true, provider saw the peer close, prompt reported cancelled 0.27s after the frame. Salvage of #106197 by @kyssta-exe (executor-future handle, cancel/timeout/ disconnect propagation) and #106320 by @Xixiartemis (deterministic lifecycle regression: terminal(cancelled) => no owned request or worker remains live; interrupt-on-late-registration). Both rebuilt slimmer: #106197 keyed its fallback on Future.cancel() returning False, but the handle it held was run_in_executor's asyncio wrapper, whose cancel() returns True while the thread keeps running, so its thread-name abort registry was never consulted; #106320's command-scoped ownership model is folded into one small module hooked at the turn facade instead of a per-caller `bind_agent`. Co-authored-by: kyssta-exe <218078013+kyssta-exe@users.noreply.github.com> Co-authored-by: Xixiartemis <182932319+Xixiartemis@users.noreply.github.com>	2026-09-09 10:58:16 -07:00
teknium1	8d93081971	fix(desktop): stop flagging local/LAN auxiliary pins as stale ... An aux task pinned to a private endpoint via `base_url` (a home Ollama box at `byron.local`, a LAN IP, localhost) is the intended per-task endpoint feature and can never bill a provider. The Settings → Model banner still counted it as "still run on openai" forever and offered "Reset all to main", which would wipe the working local setup; the post-switch `stale_aux` report had the same blind spot; and the aux row never showed the `base_url` the backend already sends, so the pin was indistinguishable from a paid-provider pin. - `GET /api/model/auxiliary` now stamps each task with `local_endpoint`, the verdict of the one canonical classifier (`agent/model_metadata.py::is_local_endpoint`) — no TS mirror of the private-range rules, so frontend and runtime cannot drift. - Desktop: the persistent banner filter is the pure `staleAuxAssignments()` and skips `local_endpoint` pins; the pinned row appends ` · <base_url>` when one is set. - `_stale_aux_pins` (post-switch report) skips local pins the same way. - `is_local_endpoint`: `*.local` (RFC 6762 mDNS) now counts as local, and IPv6 literals no longer ride the "no dots ⇒ unqualified host" rule, so a global-scope address (`2607:f8b0::1`) is not local while `::1`, ULA and link-local still are via the `ipaddress` scope checks. Slim redo of #106236 (@webtecnica) and #106234 (@huklaa), which fixed the same symptom with a client-side classifier copy; the bug class, row display and mDNS/IPv6 classifier corrections are theirs. Refs #106228 Co-authored-by: Hukla <129692708+huklaa@users.noreply.github.com> Co-authored-by: webtecnica <webtecnica@gmail.com>	2026-09-09 10:33:00 -07:00
Teknium	e74c4a00ca	Merge pull request #69446 from NousResearch/feat/plugin-catalog ... feat: plugin catalog — curated SHA-pinned plugin index (CLI, admission CI, docs, dashboard)	2026-09-09 09:22:21 -07:00
Gianpietro Dal Zio	653418d842	fix(dashboard): coalesce expensive reads before worker admission	2026-09-09 21:16:40 +05:30
moken627-hub	35af06c009	fix(desktop): coalesce projects/tree sidebar scans and memoize raw config parses ... The all-profiles sidebar polls GET /api/profiles/projects/tree, the one heavy sidebar endpoint that was not wrapped in @_sidebar_singleflight_cache. Every poll fanned out list_profiles() + _build_project_tree() over every profile (51 on this box, ~17k SKILL.md files walked), and each profile resolution re-parsed its config.yaml because read_user_config_raw() ran uncached. On a 2-vCore VPS running 'hermes serve' for the Desktop remote backend this pinned both cores (py-spy: 110-116% sustained, HostHighCPU). - Wrap get_profiles_projects_tree in the existing single-flight cache, matching get_profiles_sessions_sidebar (5s TTL, errors[] not cached). - Memoize read_user_config_raw() on a (st_dev, st_ino, st_size, st_mtime_ns) fingerprint under _CONFIG_LOCK, same strategy as read_raw_config(). Hits return a deepcopy so write-back round-trips keep their fresh-dict semantics; parse errors are never cached; the docstring no longer claims 'no caching'. - Tests: memo semantics (deepcopy isolation, inode-replace reparse, error non-caching, parse-count), a wrapper-presence pin for both heavy sidebar endpoints, and a cold-cache autouse fixture in the scope tests (the 5s TTL otherwise leaks one test's payload into the next). Measured on the affected box: list_profiles 1.9s -> 0.16s warm, serve CPU 112% -> 22-34%, host CPU 50-70% -> ~26%.	2026-09-09 21:11:56 +05:30
Teknium	41b4555ed9	feat(plugins): catalog is the sole discovery system — re-port onto main's layout ... - hermes_cli/plugins_cmd_catalog.py: new sibling owning resolution, the .hermes-catalog.json provenance sidecar, search/info/validate, re-pin on update, and the dashboard/TUI payload builders. plugins_cmd.py only gains the hooks (cmd_install catalog branch, cmd_update / dashboard update re-pin, dashboard_install_plugin catalog_name + kill list, dispatch entries); the community index (plugin_index.py) is gone. - hermes_cli/plugin_catalog.py: catalog_dir parameter replaces the test-only HERMES_PLUGIN_CATALOG_DIR env var; live refresh reads ONE published document (/docs/api/plugin-catalog.json, 6h cache, in-tree fallback) instead of the unauthenticated GitHub contents API (60 req/h, 1 request per entry); in-tree and live removals are unioned so a stale cache can never un-block. - Catalog route lives in web_routers/dashboard_ui.py (the facade is off limits); _plugin_runtime_status shared from web_server_dashboard.py; hub rows carry removed_reason. TUI plugins.manage gains catalog_name install, catalog row fields and an update action. - plugin_validate: the probe context honours ctx.get_config defaults (real plugins do int(ctx.get_config("timeout", 180)) in register()). - Installed-state merge matches through the sidecar's catalog_name first — catalog names rarely equal manifest names. - extract-plugins.py emits plugin-catalog.json; deploy-site triggers on plugin-catalog/** so entry merges republish it.	2026-09-09 04:38:01 -07:00
Teknium	bf28c2fe1f	fix(desktop): local endpoint probes ignore HTTP(S)_PROXY; non-2xx names the status (#63472) ... httpx honours the env/system proxy (on Windows, the registry ProxyServer even with no *_PROXY vars) but never the bypass list, so a system proxy (Clash, corporate) answered 127.0.0.1 probes from both Desktop validators with its own error page. That parsed as models=[] and the GUI said "advertised no models at /v1/models" for a llama.cpp server the CLI (urllib, honours <local>) saw fine. Local endpoints (loopback, LAN, Tailscale via is_local_endpoint) now probe with trust_env=False; public endpoints keep honouring env proxies. A reachable endpoint answering non-2xx with no model list reports "<url> answered HTTP <status>." instead of an empty catalog, so the onboarding card stops telling the user to start a model. Reimplemented on the decomposed router (the original patched web_server.py before the split). Diagnosis and fix direction by Solitud1nem in #63656; Windows registry-proxy confirmation by Ulysses-Gaia on #63472. Live repro (real loopback server, HTTP_PROXY=http://127.0.0.1:9): before ok=False reachable=False 'Could not reach .../v1/models' after ok=True models=['Qwen3.6-35B-A3B-Q5_K_M.gguf'] Co-authored-by: Solitud1nem <76743883+Solitud1nem@users.noreply.github.com>	2026-09-09 03:33:06 -07:00
Teknium	478d772f2c	fix(desktop): resolve artifact downloads in their originating session	2026-09-07 07:11:36 -07:00
Teknium	fd3565deec	fix: remove dedicated user-facing output cap controls	2026-09-07 06:15:43 -07:00
Teknium	d0c90039a7	fix(messaging): keep profile status truthful without credential inheritance ... Preserve the two contributor fixes, slim them to two behavioral invariants, and enter explicitly requested homes even inside a nested scope. Real native remote Desktop changes Disabled to gateway_stopped for default and named profiles; direct API controls preserve explicit disable and empty-profile isolation. Unit A/B and regression suites remain queued under the shared campaign lock.	2026-09-07 05:56:33 -07:00
liuhao1024	9098c9a65a	fix(dashboard): guard empty-required_env platforms in the scoped enablement fallback ... all() over an empty tuple evaluates True, so the scoped credential fallback reported platforms with required_env == () (whatsapp, yuanbao, api_server, webhook, a2a, msgraph_webhook, relay, whatsapp_cloud) as enabled=True with no config entry and no credentials. Add the bool(required) guard to the enabled computation (per review suggestion) and to the configured field, which came from the same all()-over-empty expression and reported configured=True for the same shape — the unscoped branch reports enabled=False / configured=False there, so the scoped branch now agrees. Adds tests/hermes_cli/test_web_server_scoped_enablement.py covering the empty-required_env shapes, the explicit-enabled precedence, and the credentials-present path. Co-authored-by: crazyief <8566250+crazyief@users.noreply.github.com>	2026-09-07 05:56:33 -07:00
liuhao1024	5dfa2f8374	fix(dashboard): env credentials enable a platform on the profile-scoped messaging status path ... The scoped branch of _platform_enablement consulted only config.yaml's platforms: section, but the `hermes gateway setup` wizard writes .env credentials and never a platforms: entry. The desktop always sends ?profile=default (normalizeProfileKey maps the primary profile to `default`), so the Settings - Messaging page showed a working bot as "Disabled" while /api/status reported it connected (#104614). Mirror _enable_from_env (gateway/config_env.py): env credentials alone enable a platform, an explicit enabled: false still wins. Only the profile's own .env (env_on_disk) is consulted, so the root install's os.environ credentials still never leak into a profile's state. Fixes #104614	2026-09-07 05:56:33 -07:00
Gille	a99340c247	fix(dashboard): prevent PTY input from blocking event loop (#93565) ... * fix(dashboard): prevent PTY input from blocking event loop * fix(win-pty): don't terminate a healthy ConPTY on write cancellation; log leaked write workers Review follow-up to the backpressure fix. CancelledError on WinPtyBridge.write() ran the same path as a timeout and force-terminated the ConPTY. Cancellation means the owning socket went away mid-write, which is the keep-alive session's normal reattach case, not a wedged child; killing the process there defeats the PTY-outlives-socket design. Give the in-flight write the shutdown grace window and only terminate if it never lands. When terminate() fails to unblock pywinpty, the worker stays parked in the default executor. That was swallowed by a bare except; log it so a slow thread-pool starvation is diagnosable. --------- Co-authored-by: Austin Pickett <pickett.austin@gmail.com>	2026-09-04 20:24:24 -04:00
kshitijk4poor	5a0b1ba766	test(local-models): assert _assign_default reaches the real assignment body ... Follow-up to the salvaged fix from #102994. The quickstart leg tests stubbed web_deps.late itself, so the resolution path that regressed (late() -> web_server facade -> getattr) was never exercised; the PR's proposed tests pinned the module string instead, which fails on any future move of the symbol even when the call site is updated. Stub only the leaf (web_server_config._apply_model_assignment_sync) so the real late() runs, and add one invariant test: _assign_default must call it with ("main", "llamacpp", model_id, "", "", ""). Red on base (AttributeError), green with the fix; not tied to where the symbol lives. Drop the docstring parenthetical that described test mechanics.	2026-09-05 00:29:42 +05:30
Leanolf	aef409343d	fix(local-models): point _assign_default's late-bound model assignment at web_server_config ... The whole-codebase refactor moved _apply_model_assignment_sync from the web_server facade into web_server_config, but _assign_default in web_routers/local_models.py still resolved it through the default late() module (web_server), which no longer carries the symbol. A local-model quickstart therefore failed its final 'making it your default' step with AttributeError: module 'hermes_cli.web_server' has no attribute '_apply_model_assignment_sync'. Pass the defining module explicitly to web_deps.late() so the call resolves against hermes_cli.web_server_config, matching how the sibling models.py router imports the same helper. Update the two quickstart test stubs to accept the module argument the real late(name, module=...) takes.	2026-09-05 00:29:42 +05:30
Teknium	d63e380324	compat(plugins): warn once per name when a plugin resolves an old import path; lint step restored in CI ... Every PLUGIN-COMPAT __getattr__ now calls hermes_cli.plugin_compat.warn_once(facade, name, target) before resolving, emitting a HermesPluginCompatWarning (FutureWarning) once per process per name: old path, new path, removal target. Importing a facade for its live API stays silent; only resolving a moved name warns. COMPAT_MANIFEST.md documents the warning and how to silence it during migration. Verified the runtime never routes through a pointer: every entry point (run_agent, cli, hermes_cli.main, gateway.run, tui_gateway.server, web_server, model_tools + tool discovery, hermes_state, cron.scheduler, browser_tool, mcp_tool, kanban, auth) imports clean and `hermes doctor` runs end to end with the warning promoted to an error. Also restores the check_compat_pointers CI step to .github/workflows/lint.yml, which a0be177aac dropped when the compat layer was regenerated (the lint script itself was present; the workflow step was not). hermes_cli/plugin_compat.py, tests/test_plugin_compat_warning.py and the two-line insert per facade are part of the compat layer and go away with it.	2026-09-04 00:15:16 -07:00
Teknium	2776813df3	compat(plugins): temporary import-path shims for external plugins — ONE commit, revert on schedule ... The Sep 2026 decomposition (PR #102117) makes internal import paths a non-API: names now live in the focused modules that define them. This commit is the ONLY thing keeping the old paths alive, so external plugins have time to update. It is deliberately a single, unsquashed commit: git revert <this sha> removes every shim, stub and manifest at once on the announced date. Nothing in-tree may depend on these pointers: scripts/check_compat_pointers.py (wired into lint.yml) fails CI if it does. What it adds (see COMPAT_MANIFEST.md, compat_manifest.json): - 332 facade modules get one delimited `PLUGIN-COMPAT` block appended at the end of the file - 1,172 moved names resolved lazily via a module `__getattr__` (PEP 562) — never a top-level import, so no import cycles; facades that already had `__getattr__` get a chained one - 592 third-party/stdlib names the old modules used to expose, with their original import statements - 266 public definitions that had been deleted as unused, restored byte-for-byte from the pre-decomposition tree (+40 private helpers and 16 imports pulled in only because a restored definition needs them) - 3 deleted modules recreated as re-export stubs (gateway/startup_watchdog, hermes_cli/observability/ relay_runtime, tools/environments/modal_utils) - private names (`_x`) get no pointer: they were never API (3,792 skipped) Verified: all 335 touched modules import under a fresh HERMES_HOME and every manifest name resolves; the lint reports zero in-tree uses; ruff clean; targeted suites unchanged.	2026-09-03 17:13:22 -07:00
Teknium	08bd8aea74	simplify(compat): web_routers — repoint 231 web_server.<name> seams to the owning module (105 direct imports, 113 late()/LateState() with module arg, 12 lazy imports + kanban plugin _ws_auth_ok)	2026-09-03 14:21:43 -07:00