686 Commits

Author	SHA1	Message	Date
Siddharth Balyan	cf35e7351e	fix(connectors): manage_connections is absent for accounts the portal has not enabled (#111238) ... A signed-in, paid Nous account that the portal had not enabled for connectors got `manage_connections` in its schema and a raw "tool gateway request failed with status 404" back from every call. The gateway answers 404 for any such account by design, and Hermes gated the tool on paid access or a free tool pool, which says nothing about that. The gate now reads the portal's own answer: a `managed_tools` token claim, plus the existing free-tier leg. The gate is also the tool's check_fn, so a session without the claim never sees the tool and the model has no 404 to narrate. A token without the claim reads as not enabled.	2026-09-14 22:01:32 +00:00
Siddharth Balyan	ee2f5629b8	Desktop connect runs on the connection operation: one card, no link to the model, no renderer polling (NS-868) (#110574) ... * refactor(connectors): cut comments that restate the code Connector modules (tools/connectors, tui_gateway connector RPCs, desktop connector card/store) keep only comments that carry a non-derivable why or a cross-module contract. No behaviour change. * feat(connectors): managed connect runs on the connection operation Managed `connect` / `reconnect` mint one ConnectionOperation for every target and, on a desktop session, block the tool turn until the operation settles; the result is per-target outcomes and never carries a connect link. Off the desktop the result carries the links and returns at once (PR3 delivers them as their own message). Why: the previous leg handed the model a URL and a `wait` verb, and the renderer ran its own 2s poller on top of the backend's 5s one; both walked the whole gateway catalog at two vendor calls per page to read one row (~3 Composio calls/s per pending target). A hidden composer message started the model's `wait` on the user's behalf. None of it was observable from the operation the MCP leg already used. What the operation looks like now: - `contract.py`: TargetState / Actor / SettleReason enums and the `(kind, from) -> {to: actor}` transition table. `operation.transition()` enforces it; a card cannot claim a managed target `connected`, only the backend watcher can. - `live.py`: one open operation per session, found by `op_id`. `connectors.operation.status` reads it, `connection.respond` drives it, `pending_connection` on resume replays it. - `run.py`: the one lifecycle for both target kinds (prepare -> card -> wake/observe loop -> settle -> result). The managed `observe` hook polls the gateway list once per tick for the whole operation; the exact-status route replaces that call when the gateway ships it. - `connection.update` is emitted on every transition and on settlement; registered in the shared event contract with the operation vocabulary typed on the TS side. - `wait`, `_rendered_links`, `_seen_instructions`, the just-minted bounce and `_clamp_timeout` are deleted. `force` on `reconnect` always reinitiates; plain `reconnect` repairs only what the gateway reports disconnected. - `connections.wait_timeout_seconds` is removed from config defaults, the example and the docs. The deadline is `OPERATION_DEADLINE_SECONDS = 300` in `operation.py`; the key was added on this unmerged train so no migration is needed. - Wire model: `statusReason` parsed on connection results; the seven-state `connectionStatus` is typed on list items and an unknown value fails validation; `CONNECTION_REQUIRED` carries `connect_card_available` instead of the link when the session platform is `desktop`. Session platform, not callback presence, decides whether a card exists: the GUI bridge attaches callbacks to every backend session, terminal TUI included. * feat(desktop): connector card subscribes to the connection operation The card renders from the backend's operation instead of driving its own: `connector-flow.ts` (the renderer's 2s `connectors.list` poller, its 120s client deadline and `keepWaiting`) is deleted, and both hidden composer submits in `connector-tool.tsx` go with it. The model is never nudged into a `wait`; the tool call is blocked on the backend until the operation settles. - `connection-request.ts` is the operation store: keyed by `op_id`, one entry per session, `applyOperationStatus` / `applyConnectionUpdate` as pure reducers, `respond` leaves the entry in place (the backend answers with `connection.update`), `ConnectionTargetOutcome` is a discriminated union the backend's transition table accepts. - `input-requests.ts` applies `connection.update`; `connection.expire` and the resume snapshot correlate by `op_id` (a snapshot has no `request_id`). - `ConnectorOffer` renders one `ConnectorCard` per target from a single `Record<ConnectionTargetState, phase>` table; Connect opens the stored link, Try again on failed / expired reissues through `connectors.connect` on the open operation, Not now is a per-target `skipped`, Continue settles. A settled operation renders `ConnectorSummary` rows with no live control. - `tool-render-class.ts`: `manage_connections` renders the card regardless of `HERMES_GUEST_ONBOARDING`; the flag still gates the onboarding flow, not the card. The backend gate already decided admission; a card only exists because the tool was admitted. - `mcp-setup-tool.tsx` speaks the same outcome vocabulary (connected / skipped / failed). - `ConnectorRow.connectionStatus` is the seven-state literal union, not `string | null`. - The guided-onboarding poller (`first-build-connectors.ts`) keeps its own row/phase types and compiles unchanged; PR3 moves it onto the operation. anti-slop: no net-new findings (17 touched files vs 11d1a12472). * fix(connectors): the card never parks the tool thread; every update carries the snapshot Found by the pre-PR adversarial review and a real-path E2E test (both left in the tree). - The desktop `connection_callback` was still `_block("connection.request", ...)`, which parked the tool thread on a private request-id Event until a `_respond` that no longer exists for this event. `connection.respond` settled the operation but the tool waited its full deadline before the watcher loop even started. The callback now only emits the card; the operation's own wake loop is the wait. The MCP leg's blocking bridge goes with it: the card answers through `connection.respond` like every other card. - `connection.request` and every `connection.update` frame carry the full target snapshot (state, link, detail). The initial mint happened before the card existed, so the renderer never saw the links and Connect stayed disabled; a Continue settlement stamped `not_connected` on the backend while the card still showed `initiated`. The store now overlays the snapshot; no state is reconstructed from deltas. - The `connection.update` emitter is a class-level `on_change` slot on the operation, set once by `register()` (a second `register()` no longer stacks wrappers); session lookup takes `_sessions_lock`; a re-minted link on an `initiated` target goes through `refresh_link()` and emits, instead of a bare attribute write. - `session.interrupt` is checked before the first observe, so an interrupted call settles `interrupt`, not `all_resolved`. - A gateway list reporting `expired` for an initiated target is recorded with actor `clock` (the contract's owner of that edge); it raised `IllegalTransition` before. - Dead `keepWaiting` i18n keys from the deleted renderer poller removed. tests/tui_gateway/test_connector_operation_e2e.py runs the desktop lifecycle through the real tool, registry, gateway RPC handlers and callback bridge with only the HTTP client faked. * docs(connectors): prompts and docs describe the operation, not the deleted wait verb The onboarding prompts told the model to call action="wait" with timeout_seconds and to expect a hidden [setup]/[connectors] note; both are gone. tool-search.md and toolsets-reference.md said the model gets a connect link on the desktop. tui_gateway/AGENTS.md gains the connection-operation row of the surface table. * fix(connectors): the panel re-mints only a dead link Try again on a failed or expired target mints a fresh link on the open operation. A waiting target keeps the link it was minted with; the card reopens it and connectors.connect refuses to spend a second mint (LINK_STILL_VALID). The unused refresh_link() goes. The package docstring names the new siblings; the nine-name public surface is unchanged. * test(connectors): the local-batch test answers the operation the way the card does The callback stopped returning an answer in f782b26d98 (the card answers through connection.respond); this test still returned one and waited out the 300s deadline in CI. * ci: retrigger * fix(connectors): the desktop card appears outside guided onboarding Live on a signed-in macOS desktop, the two-app connect never showed a card. Three defects, each hidden by a test that bound state the running app never binds. The backend read the surface from HERMES_SESSION_PLATFORM only. The desktop and TUI gateway bind it as HERMES_SESSION_SOURCE (_set_session_context), so session_platform() was "" and managed connects took the off-desktop branch: links in the model's message, no operation. session_platform() now reads platform, then source. The E2E test binds through server._set_session_context instead of set_session_vars(platform="desktop"). The renderer routed manage_connections to the card only under isOnboardingEnabled(), the HERMES_GUEST_ONBOARDING launch flag, in message-parts.tsx and the run splitter in fallback.tsx. tool-render-class.ts had already dropped that gate in this PR; the two routers had not. Both now route on the tool name alone. ConnectorTool resolved the session owner by the runtime id. Owner routes, hints and session rows are keyed by the stored id, so in registry topology the owner never resolved and the card rendered null while the tool blocked. It now resolves by the stored id, matching the PR1.5 card and every other owner lookup. message-parts-connectors.test.tsx mounts the real Fallback router with the onboarding flag off and distinct runtime/stored ids; red before each renderer fix, green after. * style(connectors): shorter comments, no module mock in the card router test The router test mocked isOnboardingEnabled to false; jsdom has no preload bridge, so the real function already returns false. Comments that restated the code are cut to one line. anti-slop: no net-new findings (25 touched files) * fix(connectors): Connect on a waiting row opens the stored link ConnectorCard derived the button's loading state from the phase label, so a managed row that read "Finish connecting in your browser" (every row, since links are minted up front) had a disabled Connect button. Nothing on the desktop could open the sign-in link; every managed connect ended skipped, not_connected, or at the deadline. The card now takes `busy` for "the action itself is running" and keeps `phase` as a label. The MCP card passes its in-flight flag; the connector card passes the re-mint wait. Red before: the Connect button on an initiated row rendered disabled and a click opened nothing. * fix(connectors): a settled card stays dead; the card binds to its tool call only A second connect for the same apps revived the finished card on the old tool row. The connection.request payload carried no id, so the renderer fell back to matching rows by connector names, and any row with those names qualified, settled or not. The operation now records the model's tool_call_id and sends it in connection.request and in the resume snapshot. The card binds to the tool row with that id and to nothing else; the name-match fallback is deleted. A payload without the id is rejected by the store. `reason` is removed from the tool: it was the only text the card ever showed from the model and its absence forked a second tool part, since `reason` doubled as the row-correlation key in tool-parts.ts. The card never needed it. `connection.expire` is deleted from the contract and from _EXPIRING_REQUESTS: the card is raised with _emit, not _block, so nothing has emitted it since the operation lifecycle landed. Sid's rule of record: a resolved card is fully dead; no path brings it back. * fix(connectors): the watch loop settles once, on time, and never raises into the result Three findings from the live review, one loop. Continue racing a finished sign-in: the loop ran the gateway read, then settled. A read that returned `connected` for an already-settled or failed target raised IllegalTransition out of the tool and the model got a generic error instead of the per-app outcomes. The read now skips targets that are not live (pending, initiated) and skips a settled operation; the loop checks `settled` after every read. Settle reason as row text: `settle()` wrote `continue`/`deadline` into each unresolved target's `detail`, and the card printed it in red. The reason stays on the operation only. Stop and the deadline waited for the next tick: `/stop` sets a per-thread flag with no wake hook, so the sleep is sliced at 250 ms and the flag and clock are read each slice. The clock is also checked before each read, not only after. Tests: a failed mint that later reads connected settles cleanly; Continue during a read keeps the settled result; no reason in detail; an interrupt settles within the same second. * fix(connectors): MCP setup off the desktop returns unavailable instead of blocking run_mcp_operation treated a non-None connection_callback as "a card exists". Every tui_gateway session has that callback, the Ink TUI included, so an MCP install from the terminal UI blocked until the 300 s deadline while the docs promised `unavailable` with the terminal commands. The MCP path now reads the session surface the same way the managed path does; the callback is never the predicate. Test binds the surface to `tui` with the callback attached. * fix(connectors): a failed Try again shows the failure, not the old dead link The panel's re-mint ignored the gateway's per-app status and moved the row to `initiated` with whatever link came back, `None` included, so a mint that failed again rendered as waiting on the link that had already died. One reader of a mint response now serves both the first mint and Try again (`managed.mint`, with the actor as a parameter). A repeated failure keeps the row `failed`, drops the link, and carries the vendor's new text through `operation.refresh`, which emits a frame without a state change so the card redraws. * fix(connectors): a forced reconnect waits for the new sign-in before it reports connected `reconnect` with `force: true` is the account switch. The vendor keeps the old account active while the new link waits, so the first list read after the mint said `connected` and the operation settled at once: the new link was dropped and the model was told the switch was done. A forced target is marked awaiting_new_attempt after the mint. The watcher ignores its row until the list shows the new attempt (`connectionStatus: initiated`) once, then trusts `connected`. * fix(connectors): the operation registers under the gateway session key The tool registered the operation under the agent's session_id; every RPC (connection.respond, connectors.operation.status, the panel's connectors.connect) and the update emitter looked it up by the gateway's session key. Those agree until compaction rotates the agent id mid-turn; then the card's clicks find nothing, no update reaches it, and the tool waits out the deadline. The registration key is now the bound HERMES_SESSION_KEY, with the agent id as the fallback for callers with no gateway (unit tests, a bare CLI). The E2E passes a rotated agent id and drives the card by the gateway key. * fix(connectors): the forced-reconnect gate reads any non-active row; a failed re-mint of an expired row is failed Three follow-ups from the verification of the fix pass. The awaiting_new_attempt gate cleared only on the literal `connectionStatus: initiated`. The field is optional on the wire and `initializing`, `failed`, `expired` are valid values, so a forced reconnect could wait the full 300 s and swallow a failed new attempt. The gate now holds only while the row still reads as the old account (`connected` or `active`) and releases on anything else. Try again on an `expired` row whose re-mint fails raised IllegalTransition (no expired → failed edge). The re-mint steps through `initiated` as the user's attempt, then `failed`, then drops the dead link. `detail` never carries a state name any more: `failed` as detail rendered as the row label and made agent/display.py tag the settled result as a tool error. Only vendor text goes there. `connection.expire` removed from the renderer's unscoped-stream set; nothing emits it.	2026-09-15 00:41:14 +05:30
Siddharth Balyan	e0ef0eb9c3	manage_connections covers local MCP servers; setup_mcp leaves the schema (NS-867, PR1) (#109517) ... * feat(connections): manage_connections covers local MCP servers; setup_mcp leaves the schema One model tool now connects the user to apps of both kinds. A target `{"name": "linear", "mcp": true}` is a locally configured MCP server; `install` / `enable` / `authorize` are its verbs. Bare strings and `{"name": ...}` stay managed connectors and that leg is unchanged. MCP targets run through one backend-owned connection operation (tools/connections_tool_operation.py): created with a server-side deadline from the new config key `connections.wait_timeout_seconds` (default 120, floor 5, no ceiling), per-target state, and exactly-once settlement (all resolved / Continue / deadline / interrupt). Unresolved targets freeze as `not_connected` with the settle reason. Why the fold works now: the approval card is reached through `agent.connection_callback` via the agent-level inline executor table, which is the only path that carries a GUI callback. Registry dispatch (every non-GUI surface) settles MCP targets as `unavailable` with the `hermes mcp install / login` hint; managed targets in the same call are unaffected. `setup_mcp` is removed from every advertised toolset and from the deferral list; an inline-table shim keeps calls from conversations opened before this change dispatching (prompt-cache protection). `_LEGACY_TOOL_ALIASES` is not the mechanism: inline tools bypass it. Gateway: `mcp.setup.request/respond` are replaced by `connection.request/respond/expire` (no wire compat; desktop ships with this). The bridge waits exactly the operation's deadline. The `session.resume` snapshot gains `pending_connection` so a reopened window restores the card with the original deadline. `manage_connections` joins `_SEQUENTIAL_DEADLINE_EXEMPT_TOOLS`: the operation owns its wait; the 420s guard must not report `tool_timeout` while the card is live. The portal `check_fn` on the tool is dropped in favour of a handler-level gate on the managed leg, so signed-out sessions can still approve local MCPs. * wip(desktop): connection.request store, resume restore, card routing for MCP targets Renderer half of the setup_mcp fold, first slice: connection-request store (mirrors clarify), connection.request/expire handling, pending_connection resume restore, mcpTargets() + isCardTool(name, args) so MCP-target manage_connections calls classify as cards. Not yet: the card component rewrite (mcp-setup-tool.tsx), mcp-directory.ts removal, vitest, docs. Does not typecheck until the card rewrite lands. * fix(config): hermes update turns on the connections toolset for saved toolset lists `hermes tools` writes an explicit `platform_toolsets.<platform>` list, and the resolver reads absence from that list as "unchecked". The `connections` toolset (#106842) shipped after most users last saved, so `manage_connections` is stripped from the schema on every install that ever opened the picker. The Nous entitlement gate never runs; the agent reports the tool as missing. Migration 44 -> 45 (renumbered when folded into #109517; main was already at 44) appends `connections` to each explicit per-platform list that lacks it and records the offer in `known_builtin_toolsets` where that record exists, so a later uncheck reads as a decline. It skips: platforms whose record already holds `connections` (the user saw the checkbox and left it off), bare composite lists ([hermes-cli]) that already inherit it, platforms where the toolset is not allowed, and any config whose `agent.disabled_toolsets` names `connections` (Blank Slate, `hermes tools --disable`), because the resolver subtracts that list last and the enable would never take effect. The explicit-list test is the resolver's own: any configurable or plugin key. `hermes update` runs migrations post-pull for the active profile and every sibling, so one update is enough. Fresh installs and composite users were never affected. * refactor: anti-slop pass on the desktop slice; shorten added comments Parse connection.request at the boundary with a typed wire interface instead of unknown + typeof; mcpTargets reuses connectorText; comments cut to one or two lines. slop-ratchet: no net-new findings in 13 touched files. * feat(desktop): the MCP approval card answers manage_connections; MCP Directory removed The existing card (mcp-setup-tool.tsx) now reads the connection-request store, renders for manage_connections calls with mcp:true targets, answers through connection.respond with a per-target outcome, and no longer calls reload.mcp after Install; the new server's tools arrive on the between-turns refresh. A settled operation renders the first target's frozen state. session.resume restores a pending card with its original deadline on both the activate and cold-resume paths. lib/mcp-directory.ts is deleted along with its two fallback branches (suggestion provider, card install). The catalog was already primary in both; a catalog miss now yields no suggestion / a notInCatalog error. The GitHub never-suggest test is rewritten on catalog-shaped data. vitest: connection-request store (6), suggestion provider, clarify restore. slop-ratchet: no net-new findings in 19 touched files. * chore: drop __pycache__ files swept in by an over-broad git add * fix(desktop): correlate the connection.request row with the model's tool call by reason The synthetic row from connection.request and the tool.start row carried different ids and no shared match value (op_id is not in the model's args), so the card mounted twice. reason is the arg both sides carry. * docs: manage_connections covers local MCP servers; connections.wait_timeout_seconds * fix(connections): settle reason derives from target state, never from the renderer A card that answers one of two targets and claims all_resolved must settle as continue with the other target not_connected; found live with a two-target call. * fix(desktop): a pending connection card re-arms on resume and activate The store entry was restored but the transcript row was not, so navigating away and back (or reloading) lost the card while the backend kept waiting. restorePendingClarifyToolCall's core is generalized to any blocking tool name and both resume paths project the connection row through it. Verified live: card restored after navigate-away and after a full renderer reload, deadline_at unchanged, approve settles connected. * style: literal wording in added comments, docstrings and docs * fix: shared gateway-event contract and config-schema category for the connection events connection.request/expire replace mcp.setup.* in apps/shared gateway-events (json list, BACKEND_EVENT_NAMES, GatewayEventMap) so the renderer's event union includes them and the tui_gateway contract test passes. The new `connections` config section folds into the agent tab like the other single-field sections. * style: import order (perfectionist) in the desktop and shared files this PR touches * chore: retrigger CI (zero-job dispatch failure, auto-heal)	2026-09-15 00:41:13 +05:30
Teknium	a79ff58d65	feat(skills): ai-presenter-video optional skill (port of lanshu, 955★ MIT) ... Ports cclank/lanshu-create-ai-presenter-video (MIT, 955 stars in 7 days) into optional-skills/creative/ai-presenter-video. Provider-neutral presenter-video production: locked narration as master clock, avatar generation with pilot-first cost discipline, lip-sync/identity QA, captions, deterministic ffmpeg finalization with loudness normalization and contact-sheet verification. Hermes adaptations in the hub SKILL.md: SKILL_DIR resolution (upstream hardcoded ~/.codex/skills), capability mapping to text_to_speech / FAL video families / vision_analyze / hyperframes, consent-flag JSON paths (input.* vs root), preflight error-vs-remote-blocker semantics. References kept substantively verbatim (all-English upstream). Scripts unmodified. LICENSE carried. Validated hands-on: init_job -> preflight gating (blocked until manual review booleans + input.remote_upload_approved) -> finalize_delivery on a synthetic 1080x1920 render (master+share decode-verified, delivery report, 9-frame contact sheet). Cold-subagent live test: SHIP; 3 friction fixes folded in (resolution guard, boolean-flip example, preflight-writes-job note).	2026-09-13 21:12:23 -07:00
Teknium	56cc2bd814	feat(skills): scrollcraft — premium scroll-driven landing pages (port of nateherkai/scroll-craft, 1.2k★ MIT) ... Optional skill: scroll-as-timeline landing pages on a deterministic CSS/JS engine, with interview → page grammar → signature move workflow and screenshot-based scroll verification. Engine and scripts vendored verbatim; asset generation re-anchored on image_generate with the upstream kie.ai flow kept as an optional path.	2026-09-13 21:11:25 -07:00
Teknium	3304d205be	feat(video-gen): Kling 3.0 Standard + Pro families on the FAL backend ... Adds kling-v3 (fal-ai/kling-video/v3/standard/*) and kling-v3-pro (fal-ai/kling-video/v3/pro/*) to FAL_FAMILIES: start_image_url i2v key, aspect_ratio dropped on i2v, string duration 3-15s, generate_audio and negative_prompt real, no seed/resolution keys per the published llms.txt schemas. Payload shapes pinned in tests; docs mention updated.	2026-09-13 21:01:32 -07:00
Teknium	ce318290bd	Inspired by Factory Droid: /queue prompts are now listable, editable, and reorderable before they run ... Droid v0.203 (Aug 25 2026) added 'edit queued messages' — a queued steering message can be pulled back and changed before it is sent. Hermes /queue could only append blindly: no way to see, fix, drop, or reorder queued prompts. /queue now supports management subcommands in the CLI: - /queue — list pending prompts (bare prompt still enqueues) - /queue list — same - /queue edit N <p> — replace item N (keeps voice sentinel, #65827) - /queue rm N — remove item N - /queue move A B — reorder - /queue clear — drop everything - /queue add <p> — force-enqueue prompts starting with a management word Queue mutations hold queue.Queue's mutex and rebuild unfinished_tasks so join()/task_done bookkeeping stays consistent. Paste references expand on enqueue and edit, matching the old inline path. Reimplementation of PR #18833 by @abhinav11082001-stack (commit was authored under a fabricated 'Hermes Agent' noreply identity that cannot be carried into history; engineering credit is theirs), hardened for current main: voice-sentinel-aware previews/edit, paste-reference expansion, queue bookkeeping asserts, out-of-range no-op tests, and docs.	2026-09-13 20:41:41 -07:00
Teknium	48bd70b586	Port from nearai/ironclaw#7378: doc-fact contract test keeps slash-commands.md in sync with the command registry ... Two-direction contract test (tests/website/test_slash_commands_doc_parity.py): every CommandDef must be documented under its name or an alias, and every doc table row must resolve to a registered command. Ported from IronClaw's doc-fact contract tests (nearai/ironclaw#7378), adapted from their clap --help parser to our COMMAND_REGISTRY single source of truth. Real drift it caught, fixed here: /loop (alias /proactive) shipped with a full feature page (user-guide/features/loops.md) and CLI+gateway handlers but never got a row in the slash-commands reference. Added to both the CLI Session table and the messaging table, plus the both-surfaces note.	2026-09-13 20:40:45 -07:00
teknium1	2c0bec33f9	feat(model-pickers): reasoning effort selection on every model picker ... The Desktop composer got a reasoning-effort pill this morning; every other place a model is picked still left the effort to a separate command (`/reasoning`) or a hand edit of config.yaml. `hermes model` had one effort step for Copilot only, and its auxiliary-model menu had none at all even though every aux block already reads `auxiliary.<task>.reasoning_effort`. One request now carries a model pick AND its effort on every surface: - `hermes_cli/model_switch.py`: the single `/model` parser accepts `--reasoning <level>` (validated against `parse_reasoning_effort`; unknown level -> `MODEL_SWITCH_ERR_BAD_REASONING`; Unicode-dash normalized like the other flags). `ModelSwitchRequest.reasoning_effort` rides with the pick. - Classic CLI (`cli_model_switch_mixin`, `cli_tui_mixin`): `/model X --reasoning high` applies the effort AFTER the agent swap (`switch_model` re-resolves `reasoning_config` from config.yaml, so an earlier write is clobbered) with the pick's scope (session; config on `--global`; `--once` snapshots and restores it). The `/model` picker gains a third stage, "Reasoning effort for <model>", built from `VALID_REASONING_EFFORTS` + none + "Keep current effort"; hidden when the inventory capability map says the route has no reasoning control. - TUI gateway (`tui_gateway/model_switch.py`, serves Ink TUI + Desktop): `config.set model "X --reasoning high"` applies after the swap; session pin (`create_reasoning_override`) by default, `agent.reasoning_effort` on --global, one-turn restore carries `reasoning_config`; re-emits `session_info` so the status bar shows the new effort. - Ink TUI `ModelPicker`: step 3/3 (same rows, same capability gate) emitting `<model> --provider <slug> --reasoning <level> <scope>`; the new-session draft label strips the flag like `--provider`. - Messaging gateway `/model`: `--reasoning` goes through the existing `_apply_reasoning_selection` (the `/reasoning` applier) with the pick's scope. - `hermes model`: one shared post-pick effort step for the MAIN model (replaces the Copilot-only inline prompt; Copilot keeps its per-model level set via `github_model_reasoning_efforts`, other routes get the ladder, catalog `supports_reasoning=False` skips it) plus a "Reasoning effort for the current model..." row. The auxiliary menu's provider->model and custom-endpoint flows end with the same step (+ "Provider default"), stored as `auxiliary.<task>.reasoning_effort` / `delegation.reasoning_effort`, shown in the task list ("openrouter · model · high"), cleared by "Reset all to auto"; tasks whose block omits the key by design (MoA slots, memory_query_rewrite) skip it. Live (temp HERMES_HOME, stub key, no model call): - `hermes model` -> aux -> Vision -> OpenRouter -> model: before ends at "Vision: openrouter · <m>", no key written; after adds "Select reasoning effort" and saves `reasoning_effort: high`. - `hermes model` -> DeepSeek -> model: before no effort step; after the step writes `agent.reasoning_effort: xhigh`. - tui_gateway stdio: `config.set model "... --reasoning high --session"` before errors "Model names cannot contain spaces"; after switches and `config.get reasoning` returns high; bad level -> the canonical error text. - classic CLI `process_command`: before the same spaces error; after "Reasoning effort: high" under the switch summary, `--global` writes config. - `hermes --tui` PTY: /model -> step 1/3 -> 2/3 -> 3/3 -> high; transcript "reasoning: high", status bar "fable 5.1 high".	2026-09-13 16:43:50 -07:00
teknium1	2dfd831d3b	fix(webhook): bind a subscription to a profile with --route-profile, not --profile ... The salvaged flag was spelled --profile, which collides with the global -p/--profile that hermes_cli.main scans BEFORE argparse: `hermes webhook subscribe x --profile compta` would switch this CLI process to compta's HERMES_HOME and write the subscription into compta's webhook_subscriptions.json — a file the default gateway's webhook adapter never reads — while the route still lacked the profile key. #109020 special-cased the scanner for the webhook subcommand; naming the flag --route-profile removes the ambiguity without touching _scan_profile_flag: -p picks the gateway whose subscriptions file is written, --route-profile picks which /p/<profile>/ prefix may hit the route. Docs: cli-commands reference row, multi-profile-gateways webhook section, the route `profile` field. Builds on #109020 (fangliquanflq). Fixes #109016.	2026-09-13 15:45:57 -07:00
teknium1	630a4eb3a1	docs(mcp): mTLS credentials count toward connection sharing; OAuth token path is per profile ... The multiplex guide now says client_cert/client_key are part of the "same credentials" test and states the OAuth rule as its own sentence; the MCP config reference names the per-profile token directory and the never-shared-across-profiles rule next to the OAuth behaviour list. Co-authored-by: ly6751 <99090550+ly6751@users.noreply.github.com>	2026-09-13 14:38:20 -07:00
teknium1	0c0875b746	chore: delete orphaned bench data, datagen examples and stale one-off docs ... Nothing in the tree reads any of these; they landed with feature PRs and were never routed to their proper home. - mcp-research-data/: 224K of July tool-search bench result rows. The harnesses (scripts/tool_search_livetest_ue*.py) write their output to a gitignored dir; the rows were committed by hand once and the headline numbers already live in the bench commit messages. - datagen-config-examples/: Feb 2026 RL datagen configs for a WebResearchEnv that no longer exists; the yaml paths point at a configs/ dir that was never created. - docs/: ADR log with one entry, an implemented cron-doctor spec, an RCA for a resolved bug, two RFCs whose work shipped, an unimplemented profile-builder proposal, the kanban dialog mock HTML and the kanban v1 spec PDF. profile-routing.md duplicated the profile_routes section of website/docs/user-guide/multi-profile-gateways.md. Kanban docs and the `hermes kanban` parser description pointed readers at the PDF; those now point at the user guide (the patterns table it was citing is on that same page).	2026-09-13 06:06:46 -07:00
Teknium	b6b53c69a6	docs: document OpenRouter @preset references in /model (follow-up to #99633)	2026-09-12 22:21:21 -07:00
Teknium	337ef8f8ce	docs(matrix): remove phantom matrix_* agent tools and MATRIX_TOOLS_ALLOW_* gates from docs (#100535) ... The Matrix docs described six agent-exposed matrix_* tools and three MATRIX_TOOLS_ALLOW_* env gates that were never implemented — the tool names and gates appear nowhere in code. Docs now describe actual behavior: no Matrix-specific agent tools; reactions/redactions are internal to approval prompts and pickers; MATRIX_ALLOWED_ROOMS scopes responses. Fixes #100535.	2026-09-12 22:16:49 -07:00
Teknium	0c2e66ea8b	test(auth): OpenRouter PKCE invariants, fake-authority A/B harness, docs, contributor map ... Two invariant tests (red on main): the PKCE key lands as an api_key pool row that resolve_provider("auto") picks up while the bare --api-key path keeps its default, and a forged callback path is a 404 while the genuine nonce path yields the code. evals/openrouter_pkce_ab drives the real auth_add_command against a local fake /api/v1/auth/keys (verifier check, single-use codes) for legit / wrong-state / replayed-code / malformed-response / api-key-path.	2026-09-12 22:07:41 -07:00
teknium1	08a2e7dbcc	refactor(cli): vim mode is a config key only — drop the /vim slash command ... Maintainer ruling: no new slash command for this. `display.vim_mode: true` in config.yaml enables vi keybindings in the composer at startup; the NORMAL/INSERT/REPLACE status-bar label stays. Removes the CommandDef, the handler, its dispatch-table entry and slash-command docs; documents the key under Display Settings.	2026-09-12 22:00:02 -07:00
Sam Foreman	968fdc4746	fix(cli): apply /vim salvage to decomposed layout, trim tests, docs ... - Relocate _handle_vim_command and _vim_mode_label onto cli_status_bar_mixin.py (the mixin owning status-bar commands and rendering) — the original targeted pre-decomposition cli.py; slash dispatch picks the handler up by naming convention - Wire the vim label into the current status-bar fragment builder - Trim tests to 3 invariant tests per the salvage bar - Document /vim in reference/slash-commands.md Live E2E (tmux + PTY, temp HERMES_HOME): /vim toggles on, Esc/i flip NORMAL/INSERT in the status bar, /vim off restores emacs bindings, display.vim_mode persisted to config.yaml.	2026-09-12 22:00:02 -07:00
Teknium	47c029927f	feat(skills): add dream-loop — concept-art visual fidelity build loop (port of achimala/dream-loop, MIT) ... Port of https://github.com/achimala/dream-loop (MIT, 400+ stars in 48h). An autonomous loop for building visually impressive 3D scenes/games: generate photorealistic concept art, build (three.js/WebGL/Blender), screenshot the live build, judge screenshot-vs-concept on a 5-tier score ladder, iterate to convergence with explicit exit criteria. Prose-only port rebound to Hermes-native tools: image_generate for concept art, vision_analyze for judging (side-by-side composite workaround documented), browser_exec capture_screenshot for live builds, delegate_task for parallel asset work. Upstream ladder, failure modes, time-budget and exit rules preserved. optional-skills/ placement.	2026-09-12 21:42:37 -07:00
teknium1	f41b2c615d	feat(skills): system-atlas — explorable isometric architecture atlases (port of inkboard/system-atlas, MIT) ... Ports the system-atlas agent skill: one data.mjs file renders both an interactive isometric HTML map (progressive-disclosure chapters, moving data packets, question tracking by Q-ID) and a generated text twin (SYSTEM.md) for the repo. Why: architecture discussions that outgrow a single diagram — the skill encodes hard-earned rules (max 3 structures per chapter, shapes+labels, docs-policy ask before committing). Upstream 410 stars since Aug 20, VoltAgent-listed; complements architecture-diagram (static SVG) with an explorable, stateful artifact. - optional-skills/creative/system-atlas/: SKILL.md (89 lines), references/ (design language, process lessons), assets/ (build.mjs, template.html, data.example.mjs) vendored verbatim; LICENSE.txt (MIT, Harshyt Goel) - Live smoke: node --check both .mjs OK; node build.mjs produced atlas.html (41.5 KB) + SYSTEM.md from the example data, zero deps - docs: own catalog row + generated page + sidebar entry only	2026-09-12 21:28:58 -07:00
Teknium	b35c0284a1	feat(skills): add mono-color — one/two-ink editorial print images (port of yanliudesign/mono-color-skill, MIT) ... Port of https://github.com/yanliudesign/mono-color-skill (MIT, 2.9k stars in 3 weeks). Generates original one-ink or controlled two-ink editorial print images (risograph/duotone/monochrome poster aesthetic) driven by machine-readable design-system catalogs: substrate/ink palettes, composition geometry, typography roles, rhythm, controlled imperfections — all vendored verbatim as the source of truth. Upstream 34 KB SKILL.md restructured into a hub (143-line core + three references). Image generation rebound to image_generate; hardcoded '~/Desktop/Claude skills' path replaced with a neutral output dir. Upstream examples/ are all-rights-reserved (ASSET-LICENSE.md) and are NOT vendored — MIT text + catalogs only, with a NOTICE. optional-skills/ placement.	2026-09-12 20:58:38 -07:00
teknium1	d7a56474fc	feat(skills): pr-lens — animated architecture/data-flow diagrams for PRs (port of coldteadotai/pr-lens, 1.1k-star MIT) ... Ports the pr-lens agent skill: represent a diff or subsystem as one graph.json document and render it as animated SVG diagrams via the MIT npx CLI (@coldtea/pr-lens-cli), with optional opt-in publishing to a shareable canvas link. Why: PR review and architecture explanation keep producing hand-drawn Mermaid; this gives validated, animated, drill-down diagrams with a deterministic document format. Upstream created Aug 20, 1.1k stars in 3 weeks, GitHub App + Action + CLI + skill. - optional-skills/software-development/pr-lens/: SKILL.md (145 lines), references/ (config, graph document format, valid example) vendored near-verbatim, LICENSE.txt (MIT, Coldtea AI) - gh --attach caveat handled: installed gh 2.97 lacks the flag; skill documents honest fallbacks (gist, canvas link, local path) - Live smoke: validate + render of the vendored example graph passed (4 SVGs + manifest produced) - docs: own catalog row + generated page + sidebar entry only	2026-09-12 20:47:00 -07:00
teknium1	c6f87deb2c	feat(video): OpenRouter backend covers every model on the live video catalog ... The salvaged #103267 plugin hardcoded a single model (minimax/hailuo-3-max) and rejected any other id. OpenRouter's public GET /api/v1/videos/models already publishes every generative model with its supported durations, resolutions, aspect ratios, frame-image support, audio and seed flags, and pricing SKUs, so the provider now reads that catalog (5-min TTL, offline snapshot fallback): - list_models(): all 25+ generative models (edit/upscale/avatar rows that take no duration are outside the unified video_generate surface and are dropped) with a per-second price label where the SKU is per-second - capabilities(): the CONFIGURED model's surface, so the dynamic schema only advertises audio/seed/resolutions the selected model honours - _build_payload(): clamps duration/resolution/aspect ratio to the model's live limits (nearest by value/height/ratio) and drops generate_audio/seed for models that lack them (the API 400s otherwise); reference images ride in input_references; local file inputs are refused (OpenRouter fetches URLs itself), data:image/ URLs from the sandbox chokepoint pass through - bearer key only ever goes to the configured origin (poll + /content), never to a provider-supplied unsigned_urls host (kept from #103267) Also drops the source-grep `_IGNORES_SEED` escape hatch #103267 added to the declaration⇄implementation sweep; the provider now implements seed for real. Docs list OpenRouter and DeepInfra as bundled video backends. Requested by Don Piedro Savastano (Discord): OpenRouter credit for video_generate.	2026-09-12 13:44:52 -07:00
teknium1	819988acb7	docs(kanban): per-platform opt-in is the documented path (hermes tools enable kanban --platform X)	2026-09-12 12:32:55 -07:00
teknium1	49aed6e81c	docs(profiles): --clone copies the curated memory files, not just config ... The profiles guide promised "fresh sessions and memory" while _CLONE_SUBDIR_FILES deliberately copies memories/MEMORY.md and USER.md (curated identity, same tier as SOUL.md). State the real behaviour and how to get a blank memory, so #10376's first half stops surprising people. Refs #10376	2026-09-12 08:48:24 -07:00
bixycler	70d0f556d7	fix(branding): use the Caduceus ☤ (U+2624), not the Rod of Asclepius ⚕ (U+2625) ... Every inline glyph — CLI banner/status bar/response labels/goodbye, setup and doctor boxes, gateway update prompts, WhatsApp reply prefix, TUI theme, locale strings and the docs — used ⚕, the staff of Asclepius (medicine). Hermes carries the Caduceus ☤. The ASCII-art logo was already correct. Mechanical swap across 60 files (no logic change); both glyphs are East-Asian-width Neutral so no layout shifts. Skins that set their own `response_label` / `goodbye` are unaffected. Direction from PR #7064 (@bixycler), the earliest of #7064 / #9611 / #15574, redone against current main. Fixes #9565	2026-09-12 08:25:54 -07:00
teknium1	535fd88c70	fix(backup): keep durable cache/ artifacts (images, citation ledger) in full backups ... Excluding cache/ wholesale at profile roots dropped media the gateway delivered to or received from the user (cache/images, audio, videos, documents, screenshots) and the grounded-citations evidence ledger (cache/citations/ledger.json) — none of which can be regenerated. Prune only the regenerable cache/<x> subtrees; keep those six.	2026-09-12 08:25:49 -07:00
teknium1	b97ae5c9b8	fix(backup): make the socket test runner-safe and document the new exclusions ... The picked test bound an AF_UNIX socket at pytest's tmp_path, which overflows the ~108-byte sun_path limit under scripts/run_tests.sh's deep temp root ("AF_UNIX path too long"). Bind by a relative name from inside the temp HERMES_HOME instead; the walker still sees the same absolute entry. Also list cache/ + runtime roots and non-regular entries in the `hermes backup` "What's excluded" docs so the user-visible behaviour change is documented.	2026-09-12 08:25:49 -07:00
Teknium	f364c19775	feat(plugins): touchdesigner ships as a catalog plugin (MCP server + skill), optional skill retired ... The twozero TouchDesigner integration now lives in one installable unit: plugin-catalog/touchdesigner.yaml points at NousResearch/hermes-plugin-touchdesigner (portable Agent Plugins v1: mcp.json registers the twozero Streamable HTTP hub, skills/ carries touchdesigner-mcp). `hermes plugins install touchdesigner` + `hermes plugins enable td` replaces the optional skill whose setup.sh hand-wrote an mcp_servers block. The manifest name is `td` because Hermes names portable MCP tools mcp__agent_plugin_<name>_<hash>__<server>__<tool>; twozero's longest tool under a `touchdesigner` namespace is 71 chars, past the 64-char provider function-name cap. optional-skills/creative/touchdesigner-mcp and its generated docs (bundled, optional, zh-Hans) are removed; catalog tables, sidebar and kanban-video-orchestrator references are updated to point at the plugin. Supersedes #68607 (MCP-catalog-only approach).	2026-09-12 05:15:22 -07:00
Siddharth Balyan	b7b35a84b7	docs: remove the Nous guest free-tier guide (#108991)	2026-09-12 10:06:04 +00:00
Teknium	be82d52cb7	docs: migrating from per-profile gateways to the multiplexer ... What `hermes update` does, blockers and fixes, URL change for inbound-port profiles, the post-create restart reminder, rollback, and the `gateway migrate` reference row.	2026-09-12 01:49:28 -07:00
Teknium	bf867d3c74	chore(skills): ship dynamic-workflow as an optional skill ... Install with hermes skills install official/autonomous-ai-agents/dynamic-workflow. Orchestration-campaign guidance is niche enough not to sit in every default prompt index.	2026-09-12 00:02:10 -07:00
Teknium	fb4ed7b284	docs(skills): dynamic-workflow v2 — background-first delegation, campaign lessons from #102117 ... Main moved under take-1: top-level delegate_task is background-forced (results re-enter as messages; synthesizing on the same turn reads files that do not exist yet), per-task `toolsets` is gone (children inherit the parent's set), DELEGATE_BLOCKED_TOOLS is {delegate_task, clarify, memory, send_message, cronjob_manage} (execute_code is NOT stripped), and the 457-char description was truncated by the 60-char routing budget. All four bbopen review items fixed. Adds the campaign shape learned running the 1,863-session / 19-hour whole-codebase simplification fan-out (#102117): shared brief + exclusive file ownership, commit-per-step as the only handoff, fleet ceiling before the OAuth refresh stampede, per-round integration with a frozen base and a full suite on the combined tree, `rev-list --count` per branch before declaring a round done (168 late-slice commits were once left behind), one serialized test runner, forward-port last, live QA as its own wave, refuting the parent's own heuristics with the same attempt/refuter mechanic, HANDOFF.md on restart. Frontmatter now meets the hardline standard (platforms, ≤60-char description, modern section order); `/tmp` replaced by the terminal temp dir so the skill is correct on Termux and Windows. Catalog + sidebar + generated page added.	2026-09-12 00:02:10 -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
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
Siddharth Balyan	4bdd64b334	The free tier is created in one place, at boot, only behind HERMES_GUEST_ONBOARDING=1 (NS-847) (#107697) ... * fix(auth): close the free tier's gaps against the gateway's welcome-tier contract The inference gateway's welcome tier (NousResearch/api DOCS/anon-tier/plan.md) serves an anonymous account exactly one model on its own host, refuses everything else with a structured 429, cross-refuses a request on the wrong host with a 400 (403 while the tier is dark), and tells a signed-in account that still asks for `nous/welcome` what to switch to in an `x-nous-model-switch` header. Four client-side gaps against that contract: - Auxiliary calls were refused on every session. The auxiliary client asked the welcome host for the Portal's recommended compaction/vision model, a guaranteed 429 `model_not_free` before each fallback. On the welcome host it now uses `nous/welcome` (its backing model covers auxiliary work) and skips Nous for vision, which the welcome model does not take. - The structured 429 body was never read. The classifier now parses `reason` / `retry_after` / `alternates` / `upgrade_url`: `model_not_free` and `feature_not_free` are non-retryable gates that fall back; `at_capacity`, `admission_closed` and `rate_limited` are rate limits that honour `retry_after` and never rotate the free tier's only credential. The wrong-host 400 and the dark-tier 403 are deterministic, so they abort this route and fall back instead of retrying or re-exchanging. The terminal paths say what happened and name the sign-in (`/login` in a chat, `hermes auth upgrade` in a terminal). - The `x-nous-model-switch` header was ignored. The chat-completions transport records it beside the rate-limit and credits headers; the next call moves the session, and the config default when it still names `nous/welcome`, to the backing model the gateway named. - A guest fell back to the paid host. With `inference_base_url` absent from the exchange or outside the host allowlist, routing defaulted to inference-api, where every request is a 400. A guest now defaults to the welcome literal at the exchange, in the shared store's shape, and in effective routing. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> (cherry picked from commit fc758aad7efceff6223fc144a9b5c69f13e41bd8) * feat(auth): the free tier is set up on request; nous.guest_setup decides whether also on first use A caller that names nous/welcome on a Nous route with no Nous identity in reach — the guided setup's session (provider=nous, which skips the resolver's nothing-configured rung), the free-tier picker row, a bare --provider nous pointed at it — is asking for the free tier. The OAuth runtime rung now sets it up there instead of failing "not logged in", so the guided chat no longer races the root profile's first-run mint. nous.guest_setup is the policy seam: "auto" (default) keeps today's first-use setup wherever nothing else is configured; "on-request" mints only when the free tier is asked for by name (nous/welcome, /login, hermes auth upgrade, replacing a retired identity). Implicit callers — the resolver's last rung, the first-run check, free_tier.status, the CLI's background setup, the connector token path — still adopt what the shared store holds, so every profile follows the one identity the guided setup created, but never create one on their own. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> (cherry picked from commit ae915ddc65ecdb81b81e29b604671d15cd49233c) (cherry picked from commit 62ad1ff3ab200ea064975a32c502041b25910165) * feat(auth): the guided setup provisions the free tier explicitly; nous.guest_setup is auto | explicit Two questions govern the free tier: may it exist (nous.guest) and who may CREATE the identity (nous.guest_setup). "auto" (default) keeps today's first-use setup wherever nothing else is configured. "explicit" means Hermes never creates one on its own: the only creator is the new provision_free_tier() primitive, exposed as the free_tier.provision RPC, which the guided setup on Hermes Desktop calls as its first step — on the root gateway, before the setup profile and before the guided chat exists — so the identity lands in the root store every profile reads through and is there before any session asks for nous/welcome. That closes the race against the backend's own setup, and makes "only when the setup-bot flow is used" literally true. The earlier "on-request" tier is replaced: it minted whenever any caller named nous/welcome (the hermes model row, --provider nous), which treated a model name as intent and was broader than the guided setup. Under "explicit" a nous/welcome request with no identity fails "not logged in" as before the free tier existed, and /login or hermes auth upgrade report nothing to sign in from. Implicit callers still adopt an identity the shared store holds, and a retired credential is replaced (a continuation, not a creation). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> (cherry picked from commit c63d2c935c1e59016164fdfb90cf70b4094466a0) * fix(auth): remove the nous.guest_setup knob; the free tier is created on first use `nous.guest_setup: auto | explicit` decided who may CREATE the free-tier identity. Under its default every line it added was inert (`may_mint` always true), nothing in tree set `explicit`, unknown values read as `auto`, and under `explicit` a CLI-only install could never get an identity, which contradicts the first-run contract (first command mints, then chats). The mint race the knob accompanied is already benign: every caller takes the profile lock then the shared-store lock, and the loser adopts what the winner wrote. What makes the guided setup win deterministically is `provision_free_tier()` behind the `free_tier.provision` RPC, which stays. `nous.guest` remains the only free-tier policy. Removed: `guest_setup_policy()` and its constants, the `explicit=` / `may_mint=` threading through `ensure_portal_identity` and `_reconcile_and_provision`, the flag at the three replacement call sites (now no-ops), the config default, the docs section, and the four `guest_setup` test-config entries. The three policy tests that hold regardless of the knob are kept under `TestExplicitProvision`; the two that only tested the knob are deleted. (cherry picked from commit d8a50526d93c374c0067dd935b5a65055e0af261) * fix(gateway): a server-driven model switch off nous/welcome does not evict the cached agent When a signed-in account still asks the paid host for `nous/welcome`, the inference gateway serves the current backing model and names it in `x-nous-model-switch`. `apply_model_switch` moves the live session to that model and moves `config.yaml`'s default off the alias in the same step. The messaging gateway's fallback-eviction check compares the agent's model with the config default and evicts on any mismatch that is not a /model override, so when the config write did not land (unreadable config, lock) the cached agent was evicted once per turn, and prompt caching with it. `apply_model_switch` now stamps the alias it moved the session off on the agent, and `_is_intentional_model_switch` treats "agent moved off the alias the config still carries" as deliberate, beside the existing /model override case. The check takes the agent and the config model instead of a bare model string; its one caller in `_run_agent_evict_on_fallback` passes them. (cherry picked from commit 696d1ec86b69db28bf002c841e9389b85178a954) * fix(auth): the free tier outranks implicit host credentials in provider resolution On a fresh install with a leftover ~/.aws profile, resolve_provider("auto") reached the Bedrock rung before the free-tier rung, so the first turn ran on Bedrock and failed 403 while the free tier was still being minted in the background at agent setup (NS-829). Live on a Mac with ~/.aws present: 28 s, three retries, no answer; the next process then switched to nous/welcome. The free-tier rung now sits directly above the Bedrock chain: when nous.guest is on, an existing free-tier identity answers, else a blocking mint runs, and only then does the boto chain get a say. Everything above is unchanged and still wins: CLI creds, config.yaml model.provider, env keys, the OpenRouter pool, a logged-in active_provider. nous.guest: false skips the rung, and a failed mint still falls through to Bedrock and the no-provider guidance. Tests: six precedence cases (identity present, fresh mint, free tier off, env key still wins, sign-in still wins, failed mint falls through). The opt-out test now neutralizes the AWS chain like the precedence tests do; on a machine with ~/.aws it was failing for the same reason as the bug. Live after the fix, same Mac, AWS credentials visible, isolated shared store: identity minted 2 s in, turn on model=nous/welcome provider=nous, answer in 11 s. (cherry picked from commit a04b05260cd334dd7199ad9b6cd5b2538364c75a) * fix(auth): review follow-ups for the free-tier rung (NS-829) - tests/agent/test_bedrock_integration.py: the Bedrock auto-detect test switches the free tier off; its contract is the boto chain, and the free tier now sits above it. - gateway/run_notifications.py: the free-tier startup line reads auth.json before consulting the resolver, so a gateway boot on a machine with AWS credentials never mints or refreshes over the network. - hermes_cli/anon_auth.py: module docstring says where the free tier sits in the ladder instead of "the ladder is untouched". - tests/hermes_cli/test_provider_precedence.py: two invariant tests instead of six (parametrized ladder cases; a failed mint that returns None or raises falls through to Bedrock). scripts/run_tests.sh on the five affected files: 147 passed, 0 failed. (cherry picked from commit 10790d148c60ada11b9ecdde2cd2c836c6a82a11) * feat(auth): HERMES_GUEST_ONBOARDING=1 is the one launch gate for the free tier; HERMES_FORCE_GUEST is gone The free tier is pre-GA. Until GA it must not exist for anyone who did not ask for it: no identity minted, no portal traffic, no free-tier copy on any surface. One environment variable now decides that, and one function reads it. `guest_enabled()` returns False unless `HERMES_GUEST_ONBOARDING` is exactly "1"; only then does `nous.guest` (the user's off switch) get consulted. Every free-tier site already funnels through `guest_enabled()`, so the gate closes minting, routing, connector entitlement, status lines and the picker row in one place. With the variable unset, `resolve_provider("auto")` on a fresh install raises `no_provider_configured` exactly as upstream does. `HERMES_FORCE_GUEST` and `force_guest_mode()` are removed. They inverted the gate (forced the tier ON over `nous.guest: false`), their "new" value re-minted identities as a side effect of provider resolution, and `_has_any_provider_ configured` read them ahead of every other check, making the CLI a second reader of a flag that must have exactly one. `_forced_new_done` and the `force` parameter of `_reconcile_and_provision` go with them. Supersedes the dev lever introduced in fcf9d11679 (rung 1) and hardened in b5c162c3ec. Ruling: NS-845 Q1.1 (recorded on NS-847). Not a user preference: the variable is never written to config.yaml or .env and never shown in setup. It is deleted at GA together with its comment in anon_auth.py. This is a deliberate, temporary exception to the "no new HERMES_* env vars for non-secret config" rule. Tests: fixtures set the gate instead of deleting the old lever; one new invariant (`test_launch_gate_off_means_no_free_tier_at_all`) proves that "", "0", "true" and "new" all leave the tier off with zero portal calls, red on the previous commit. The `HERMES_FORCE_GUEST=new` re-mint test is deleted with the feature. * feat(auth): the free-tier identity is created in one place, at boot; every other site is a read Before this commit eight sites could create a Nous free-tier identity as a side effect of something else: resolving a provider, the CLI's first-run check, the CLI's session setup (in the background beside an own key), a connector bearer read, the desktop polling `free_tier.status`, the sign-in precondition, the desktop's `free_tier.provision`, and the dead-credential re-mint. A poll could mint. Provider resolution could hit the network. Two of them raced each other on a fresh install. Now `hermes_cli/free_tier_bootstrap.py::run_bootstrap` is the only creator. `hermes serve` runs it on a daemon thread from `_lifespan` beside the other background boots; `cmd_chat` runs it synchronously before the first-run guard. It inventories credentials first (`resolve_provider("auto", skip_free_tier=True)`: what would carry inference if the free tier did not exist), creates the identity only when `guest_enabled()`, resolves inference, records a `SetupRecord` in process memory and broadcasts ONE `setup.ready` event. It runs on every boot; only the mint is gated. `ensure_portal_identity` now requires `explicit=True` and raises otherwise. Its callers are the bootstrap, the desktop's `free_tier.provision` (the explicit retry when the boot could not create the identity) and the two dead-credential replacements (`auth_nous.resolve_nous_runtime_credentials`, `managed_tool_gateway._replace_dead_guest_token`). The background thread path and `provision_free_tier` are deleted with their last callers. Reads that used to mint and now only read: `auth.py::resolve_provider` rung 7 (an existing identity still outranks the Bedrock chain, NS-829 ordering kept), `main.py::_has_any_provider_configured`, `cli_agent_setup_mixin._ensure_runtime_credentials`, `managed_tool_gateway.read_nous_access_token` (no identity -> None), `anon_sign_in.run_sign_in` (no identity -> Unavailable), `methods_free_tier` `free_tier.status`. `setup.status` answers from the record for the launch profile, blocking up to 8 s while the bootstrap is in flight so a client's first poll lands after the identity exists rather than racing it; a named profile, or a process that never ran the bootstrap, keeps today's live probe. The record's fields ride along additively (`ready`, `free_tier`, `other_providers`, `inference_provider`). Identity and inference are decoupled (NS-845 Q1.3): the mint sets `active_provider="nous"` only when the inventory found nothing else usable (`_mint_locked(carries_inference=)`); an adopted account always does. A token refresh no longer re-elects the provider it refreshed (`_save_provider_state_to_source` writes credentials, not the user's choice) — that write was how an own-key install ended up on the free tier after the first connector call. Supersedes the mint sites in fcf9d11679, a42d0748fc (first-run check), bbbaa8935a (CLI background setup), 0179efc989 (`free_tier.status` mint), 62ad1ff3ab / c63d2c935c / d8a50526d9 (the `nous.guest_setup` knob and `provision_free_tier`), and a04b05260c (blocking mint in the resolver). Ruling: NS-845 Q1.2 + Q1.3, recorded on NS-847. Tests: `TestBootstrapIsTheOneCreator` (one mint per process; own key keeps inference; reads never reach the portal; a refused mint is memoised), `free_tier.status` fails loudly if it ever calls the creator, the resolver stub fails loudly if resolution ever mints, `setup.status` reads the record, `skip_free_tier` proves the inventory question. The three sign-in tests for the deleted pre-mint collapse into one (`no identity -> Unavailable, zero portal calls`). Live: real `_lifespan` boot with a fake portal, gate on and off (/tmp/ns847-recon/evidence/e2e-rung5-c2-serve-boot.txt), and the CLI matrix incl. an own-key cell (e2e-rung5-c2-bootstrap.txt), 20/20. * fix(credits): the welcome host is free-tier evidence, so a free-tier identity never sees "run /topup" A free-tier identity carries $0 by design, so the portal seed reports `paid_access=False` for it. `is_free_tier_model` did not know the welcome host, read that as a depleted account, and every free-tier turn ended with the credits-depleted notice telling the user to top up an account they do not have. Rule (4) in `is_free_tier_model`: a `base_url` on the Nous welcome host (`anon_auth.route_is_welcome_host`) is the free tier. The host is the evidence, not the model name: the paid inference host can serve `nous/welcome` to a named account and that account's depletion is real, so `("nous/welcome", <inference host>)` stays False. Local data only, like the three rules above it. Restores the two contracts dropped by hermes-magic 674e11d1eaa (the prototype line ran without unit tests): the welcome host is free without any pricing evidence; the model name alone is not. The first is red without this fix. * fix(copy): free-tier text stops promising a connector transfer and never names the config key Sign-in copy on every surface said "Sign in to keep your connectors" and ended with "Your connectors are kept." The transfer registry that would make that true is empty (NS-821): nothing carries over today. The copy now says what signing in does give ("unlock more models and tools") and the completion line names the account, not a transfer. The docs page loses the "connectors carry over" paragraph for the same reason. The picker's off-state line exposed `nous.guest: false` and the word "guest"; user copy names the free tier only (R-USR-1). The docs page gains the pre-rollout note: until GA nothing on it happens without `HERMES_GUEST_ONBOARDING=1`. Its "first command mints" and "replaced on next use" sentences now describe the boot bootstrap. zh is a strict locale: the `freeTier` block was English placeholder text copied from `en`; it is now Chinese. `connectorsKept` is renamed `completedBody` since it no longer talks about connectors. * feat(desktop): the free-tier launch flag is decided once in Electron and stamped onto every backend spawn The Python backend reads `HERMES_GUEST_ONBOARDING` and treats exactly "1" as on. Until now nothing in the desktop set it, so a packaged app could never turn the free tier on, and a backend spawned by the app could disagree with the app about whether the tier was live. `electron/guest-onboarding.ts` owns the decision: `guestOnboardingEnabled` is true when the launch env has `HERMES_GUEST_ONBOARDING=1` or argv has `--guest-onboarding` (the packaged-app spelling). It is read ONCE at launch into a module constant. `desktopBackendSpawnEnv` wraps every backend env as the outermost call and writes the flag LAST, as "1" or an explicit "0", so no earlier spread (`process.env`, `backend.env`) can resurrect a stray value from the parent shell. Stamped onto all three spawn sites: the primary `serve` spawn, the pooled per-profile spawn, and the remote SSH `exec env ...` command (which gains ` HERMES_GUEST_ONBOARDING=1` only when on). The embedded terminal PTY and the backend probes are not backend spawns and do not get it: a `hermes --tui` typed in the pane must not mint. The renderer learns the same fact read-only through the existing `hermes:launch-flags` sync IPC (`guestOnboarding`) and preload (`window.hermesDesktop.guestOnboardingEnabled`). Ruling: NS-845 Q1.1 / Q2 (env var is the contract, `--guest-onboarding` maps to it in main). Two invariant tests on the pure helpers: only "1" or the argv flag enables; the spawn env carries "1"/"0" as the last word and preserves every other key. * feat(desktop): the renderer learns free-tier readiness from one `setup.ready` push, not a 60 s poll The backend's boot bootstrap now announces `setup.ready` once, after it has created (or refused) the free-tier identity and resolved the inference route. The renderer used to discover both by polling `setup.status`, `setup.runtime_check` and `free_tier.status` every 60 s from `useStatusSnapshot`; a fresh install's chip, notice strip and onboarding overlay could sit stale for up to a minute after boot, and three RPCs a minute per window kept asking a question whose answer changes only at boundaries the backend already announces. `handleLifecycleEvent` routes `setup.ready` (active source only, like `skin.changed`) to `notifySetupReady()`, a one-shot tick atom in `live-sync.ts` beside the other change ticks. `useStatusSnapshot` listens to it and runs one readiness round at once (`setup.status` + `setup.runtime_check` + `free_tier.status`). The readiness legs also run once on open and on return from another app, as today. The 60 s tick keeps only `getStatus()`. `SetupStatusSnapshot` types the record's additive fields (`ready`, `free_tier`, `other_providers`, `inference_provider`); readiness semantics are unchanged and still key on `provider_configured` + `runtime_check`. Ruling: NS-845 Q1.2 (renderer half). Tests: the lifecycle branch fires one refresh from the active source and none from another; the snapshot hook's contract is three legs on open, one leg on the tick. * fix(cli): the banner names the free tier's model instead of "no model configured" The welcome banner prints before credentials resolve, so on a fresh install `model` is empty and the banner said, in red, "no model configured — run /model or hermes setup". Under the free tier that is false: the route is already known from local state (identity on disk, tier on), and the first message will run on `nous/welcome`. `_banner_left_lines` now asks the route the same question when `model` is empty (`guest_carries_inference()`, a local read) and shows `welcome · Nous Research`. When nothing resolves the red line stays. Ruling: NS-845 ("the banner's 'no model configured' line reads the resolved route"). Live: fresh HERMES_HOME + fake portal, gate on -> `welcome · Nous Research`; gate off -> the red line, zero portal calls. * fix(aux): vision on the free tier uses nous/welcome too The text-only modality on the gateway's `nous/welcome` row is DeepSeek V4 Flash's, the backing model until the repoint; `z-ai/glm-5.3-flash` is natively multimodal and the repoint declares the welcome row `text+image->text`. Skipping Nous for vision on the welcome host would have sent every image step past the free tier for no reason, so the auxiliary client pins the route's one model for every lane. A backing model that takes no images answers with the upstream's own error, which the ladder handles as it always has. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> (cherry picked from commit 7456e028faba55480db43015dc2c8df3e393a415) * fix(gateway): hermes gateway run is a boot owner of the free tier too Rung 5 made every demand-time free-tier site a read: resolve_provider, the connector token, the /login precondition. That is only correct if every process that can reach those sites ran the bootstrap first. The CLI (cmd_chat) and hermes serve (_lifespan) did; the standalone messaging gateway did not. A fresh HERMES_HOME with the gate on and `hermes gateway run` reached provider resolution with no identity to consume, and /login returned Unavailable. Reported by @andrexibiza on #107697 (P1). GatewayRunner.start now runs `free_tier_bootstrap.run_bootstrap` on an executor thread right after startup recovery and BEFORE any adapter connects, so a fast first DM cannot arrive with nothing to resolve. It is its own step, not part of the turn-machinery warm-up: the warm-up is an optimisation with an off switch (HERMES_STARTUP_WARMUP_TIMEOUT<=0); the bootstrap is correctness and must always run. With the gate unset it is a local inventory and no network. Live, real GatewayRunner.start against a fake portal in a fresh home: gate on -> 1 create, identity persisted, resolve_runtime_provider=nous, /login precondition sees the identity gate off -> 0 portal calls, no identity, no_provider_configured Before the fix the gate-on row was identical to the gate-off row. Test: the bootstrap seam runs before _start_prefilter_platforms and delegates to the one creator. Red on 5554eb6993 (no seam), green here. --------- Co-authored-by: Robin Fernandes <robin@soal.org> Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-11 03:45:33 +05:30
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
Justin Bennington	d7b0a72c2a	fix(providers): route Actual through chat completions (E-1047)	2026-09-10 14:56:55 -04:00
Teknium	77e55b4d1f	fix(desktop): show each in-app tip once, never lap the catalog again ... The idle tip rotation walked the catalog as a ring: after the last tip it wrapped to the first, so a user who had already seen every tip kept getting "Start fresh", "Teach it once", ... again every six hours for as long as they used the app. Only the X stopped a tip, and letting a bubble time out (the normal way it leaves) counted for nothing. The walk is now one lap. nextTip also steps over every tip in the seen ledger ($tipShownAt, which already recorded every catalog tip that reached the screen), so a tip shows once however it left, and the rotation runs dry once every tip has had its moment. Settings > Reset clears the seen ledger and the cursor as well as the retired set, and its button counts what a Reset would actually bring back (shown or closed, counted once). Agent tips carry no catalog id and are untouched. Live repro (Playwright against the worktree's Vite renderer, all nine tips seeded as seen, clock fast-forwarded past settle + cooldown): origin/main re-showed "Start fresh"; fixed renderer shows nothing; a fresh user (nothing seen) still gets the first tip.	2026-09-10 11:18:16 -07:00
Teknium	2feb546828	feat(skills): archify joins the optional-skills catalog as an upstream-maintained stub ... tt-a1i/archify (MIT, 57k stars) turns a typed JSON spec into validated, self-contained interactive HTML diagrams (architecture / workflow / sequence / dataflow / lifecycle) with a 9-check validate/deliver receipt, Mermaid import and PNG/SVG/WebM export. The upstream repo already ships a complete skill directory (archify/), so this follows the impeccable pattern: a catalog stub whose metadata.hermes.upstream pointer makes `hermes skills install official/creative/archify` pull the live tree through OptionalSkillSource._fetch_from_upstream. Nothing executable is vendored and the copy can never go stale. Docs: generated page, one catalog row, one sidebar line. Credit: tt-a1i (upstream author). Supersedes the vendored-references port in #106442.	2026-09-10 09:07:35 -07:00
Victor Kyriazakos	49ef015ca3	fix: join delegated work before finite chat exits	2026-09-10 05:02:41 -07:00
teknium1	b27c6f7f0d	docs(line): document LINE_EXPIRED_TEXT beside the other postback reply knobs	2026-09-09 11:47:55 -07:00
Konstantin Khlopkov	1a981d8e83	fix(telegram): bots_require_mention gates bot quote-replies behind an explicit @mention (closes #106430) ... (cherry picked from commit a67fa8c4b21e31a44019d850aedc5be9015a546d)	2026-09-09 10:37:37 -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
Teknium	48465c3933	fix(profiles): --clone-all no longer copies cron jobs into the new profile ... Cron jobs are scheduled work bound to the source profile and its origin channel. A clone that inherited cron/jobs.json fired every job twice: two gateways with identical job ids running the same weekly jobs in parallel (double spend, duplicate deliveries) until one gateway died. Root cause: `cron` was not in _CLONE_ALL_HISTORY_EXCLUDE_ROOT, so the copytree in _clone_all_into carried jobs.json along. Add it to the per-profile history exclude set (applies to any source, CLI, dashboard and TUI/desktop RPC all funnel through create_profile), recreate the _PROFILE_DIRS skeleton after the copy so the clone still has an empty cron/ (and sessions/), and say so in the CLI summary line and docs. --clone (config-only) never copied cron; export/backup keep cron as before (an archive is a portable snapshot, not a second live profile).	2026-09-09 04:27:24 -07:00
Teknium	d47adec28f	Merge origin/main into feat/plugin-catalog ... Python plugin CLI/loader/web/tui files taken from main wholesale; the catalog layer is re-ported onto main's decomposed shapes in the following commits. plugin_index.py removed (catalog is the sole discovery system).	2026-09-09 04:15:27 -07:00
Teknium	4b6c5bee4c	docs(backup): document hermes backup --keep	2026-09-09 03:33:14 -07:00
Teknium	78afbc3c37	fix(desktop): load property card guidance only on demand	2026-09-08 13:39:01 -07:00
Teknium	abd83ab560	fix(skills): make RSS and Reddit reading optional	2026-09-08 10:07:51 -07:00
witcheer	fb3446a281	docs: eight small accuracy fixes from open type/docs issues ... Each fix verified against main @ ee84ccd on 2026-09-08. - windows-native: the troubleshooting entry told users to set HERMES_GATEWAY_FORCE_STARTUP (no code reads it), query a task named HermesGateway (hermes_cli/gateway_windows.py names it Hermes_Gateway), and described the Startup-folder fallback as a cmd.exe shortcut (it writes a .vbs run via wscript.exe). Closes #88077. - faq: 'hermes config set HERMES_MODEL ...' does not change the default model; 'model.default' does. Closes #65855. - messaging/index, slash-commands, irc: gateway settings are read from ~/.hermes/config.yaml (gateway/config.py), not gateway-config.yaml. Closes #65857, closes #78276. - telegram: reaction lifecycle is 👀 then 👍/👎 (plugins/platforms/telegram/adapter.py on_processing_complete), docs said ✅/❌. Closes #78698. - plugins: bundled memory providers win on a name collision (plugins/memory/__init__.py docstring: bundled, user, project, entry point, first seen wins); the page said user plugins override. Model providers keep the documented last-writer-wins. Closes #100281. - architecture, index: terminal backend count is seven (tools/terminal_tool.py: local, docker, singularity, modal, daytona, vercel_sandbox, ssh); two surfaces said six. Closes #78252. - quickstart: the Portal quick path was called 'free'; the login is free, the inference is billed to the subscription. Wording now matches integrations/nous-portal. Closes #78254.	2026-09-08 19:00:02 +05:30
Teknium	f5afe8bd40	feat: authorize MCP servers with device codes from the CLI ... Add explicit RFC 8628 device login and oauth.flow selection while keeping browser PKCE and the SDK runtime refresh path. Reuse issuer/resource validation, configured client authentication and profile-scoped storage. Only persist an approved, validated grant; never echo endpoint error bodies. Slim redo of #104752 by @wjorgensen, replacing duplicate HTTP/storage wrappers with the existing SDK and two real-wire invariant tests. Refs #104742 Co-authored-by: Wes Hermes <weshermes@Wess-Mac-mini.localdomain>	2026-09-07 08:22:35 -07:00