Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
merge: land the maintainer's local main on GitHub main
rubenluetke10-beeped4261028801
diff --cc docs/BUGS.mdindex c23598e182,47620d655f..4f11de4664--- a/docs/BUGS.md+++ b/docs/BUGS.md@@@ -15561,364 -15514,99 +15561,461 @@@ safe in destructors); `__del__` only enstarted in ordinary code (`LockedRecognizer.__init__`, `release_recognizer`).Guard: `tests/unit/plugins/wake/test_vosk_native.py::test_dropping_the_proxy_inside_an_executor_submit_does_not_deadlock`.+## BUG-222: the downloaded macOS app could not use a single permission — it was never accepted as "the installed app", it shipped without the microphone framework, and its Info.plist said background-only (HIGH, FIXED 2026-10-01; built and booted on macOS CI runners, not yet tried on a user's Mac)++> **Superseded in part by BUG-225 (2026-10-02).** The identity fix stands (`ACCEPTED_BUNDLE_IDS`,+> the own-id reset, the packaging fixes and the frozen-app probe), but its premise+> that a wrong identity "disables the whole permission surface" is gone: identity+> now decides only who may ask automatically and who may reset, never whether a+> feature may act (AP-35 principle 6). The `identity_ready`, `can_request` and+> "no request button means no way to be asked" wording describes the removed+> readiness model. The history below is kept as written.++**Symptom (the identity part reproduced against the port with faked macOS+frameworks; none of it observed on a Mac).** Run as the `.dmg` app with every+grant present, the permission screens read every feature "not ready", refuse+microphone capture (wake word and voice dead), tell the user to relaunch the app+from its installed location — where it already is — and offer no **Allow** or+**Open Settings** button. With no request button, a user has no in-app way to be+asked at all, and enabling the app by hand in System Settings would not change+the verdict.++**Cause, three layers.** The first is code; the other two were read off the+published v2.5.0 arm64 image (extracted and opened on Linux — its `Info.plist`,+and the module table of the archive frozen into its executable, read with+PyInstaller's own reader):++1. **Identity.** `SystemPermissionPort` accepted exactly one bundle id,+ `com.personal-jarvis.desktop`, the managed local bundle. The `.dmg` build+ (`jarvis.spec`) has its own id, `ai.personaljarvis.desktop` — deliberately+ different, because BUG-218 keeps the managed installer from rebuilding over+ it. Run against the port with every grant present, the `.dmg` identity gave+ `stable=False`, all six features `identity_ready=False`,+ `runtime_access_granted(microphone)` false and every `can_request` /+ `can_open_settings` false. The gate fails closed by design (granting Terminal+ or a bare Python would be unsafe), so one wrong constant disabled the whole+ permission surface — and nothing ever ran the port as the `.dmg` app.+2. **No `AVFoundation` in the frozen app.** The port loads its frameworks by+ NAME (`SystemPermissionPort._load("AVFoundation")`), which PyInstaller's+ static analysis cannot follow, and the macOS job installed `.[desktop,dev]`+ without the `desktop-macos` extra that carries `pyobjc-framework-AVFoundation`+ (no other direct dependency requires it), so there was nothing on the build+ machine for a hidden import to collect either. The published image's module+ table has no `AVFoundation`. By the code path the microphone permission then+ reads "unavailable" for good, and the voice gate has nothing to open on.+3. **`LSBackgroundOnly` in the published `Info.plist`.** PyInstaller sets it to+ true whenever the last executable of the `COLLECT` is a console one, and the+ `jarvis` CLI is. LaunchServices reads the key as "this app has no Dock icon,+ no menu bar and no windows". Whether the published app showed its window+ regardless has not been observed.++No headless smoke run can see layers 2 and 3: it starts the executable directly+instead of the way a user does.++**Fix.**++- `jarvis.core.branding.MACOS_DMG_BUNDLE_ID` names the second legitimate+ identity; `permissions.ACCEPTED_BUNDLE_IDS` is what the identity gate, the+ `jarvis permissions` CLI and the UI's "expected id" now use. Anything else+ (Terminal, Python, an app that merely shares the name) is still refused.+- `tccutil reset` targets the id of the app that is RUNNING, and `reset` refuses+ outright from any process that is not the installed app (it used to fall back+ to the managed id, which would have wiped the rows of a different app). It is+ scoped to one bundle id, so resetting the managed id would have left the+ `.dmg` app's own rows untouched (the documented behaviour of `tccutil`; not+ observed).+- `jarvis permissions request|open-settings` find the `.dmg` app instead of+ reporting "app not found" (`installed_macos_app_bundle_path`).+- `jarvis.spec` collects `AVFoundation` on macOS and sets `LSBackgroundOnly` to+ `False` explicitly; the macOS job installs `.[desktop,desktop-macos,dev]`.+- `scripts/ci/check_frozen_macos_app.py` runs on the built `.app` in the macOS+ job and fails the build when the bundle id is not the accepted one, the plist+ is background-only, the executable or the microphone usage string is missing,+ or the frozen archive lacks one of `AVFoundation`, `ApplicationServices`,+ `AppKit`, `Foundation`, `Quartz`, `objc`. Run by hand against the published+ v2.5.0 arm64 image it exits 1 and names exactly the two defects above.+- The frozen smoke (`scripts/ci/check_frozen_browser.py`) boots the app on macOS+ and asks it for `/api/permissions/status`: a microphone row that reads+ "unavailable", or a bundle id the port does not accept, fails the job. This is+ the only check that sees a framework whose own dependencies were left out of+ the archive, because the port swallows an import that fails at run time.++**Guards.** `tests/unit/platform/test_permissions.py` (the `.dmg` identity is+stable and gets its buttons back, foreign ids are refused, reset hits the right+id and refuses from a stranger), `tests/unit/setup/test_macos_dmg_identity.py`+(the literal in `jarvis.spec` equals the branding constant, the two ids stay+distinct, the lookup), `tests/unit/cli_ctl/test_commands_permissions.py`,+`tests/unit/ci/test_check_frozen_macos_app.py`,+`tests/unit/packaging/test_frozen_browser_smoke.py` (the decision, and `boot()`+itself against a stand-in app).++**Verification.** Unit level on Linux, against faked AppKit / Quartz /+AVFoundation: the new `.dmg` tests fail on the old code, and the probe fails on+the published image. On macOS CI runners: a branch dispatch of "Desktop+installers" (run 36923225371, commit 43eeb7ae, no release published) built the+image with the new `jarvis.spec` and `desktop-macos` extra on both the Apple+Silicon (`macos-15`) and the Intel (`macos-15-intel`) runner; on both,+`check_frozen_macos_app.py` passed, and the smoke booted the frozen app twice and+read its permission status from it: microphone `granted`, bundle id+`ai.personaljarvis.desktop` — so AVFoundation loads inside the app and the+published image's "unavailable" is gone. The `granted` itself reflects the hosted+runner's setup, not a user's decision. A first dispatch on the commit before the+booted-app check existed (run 36922688589, arm64 only, cancelled afterwards)+passed the same build and probe. **Not verified:** anything on a user's Mac —+the window and Dock behaviour with `LSBackgroundOnly` off (the smoke starts the+executable directly, not through LaunchServices), the permission prompts+themselves, Gatekeeper and notarization (the runs were ad-hoc signed: no Apple+secrets).++**Known limits, not changed here.** `Contents/MacOS/jarvis` (the CLI inside the+bundle) resolves to the same main bundle, so started from a terminal it would be+read as the app although macOS attributes that process to the terminal — the+same for the managed bundle. The Control key's Keychain-ownership migration+(`jarvis/core/control_key.py`) recognises only the managed bundle id, so for the+`.dmg` app that step is skipped and an item created by an earlier ad-hoc build+may ask once more (read from the code; not observed).++**Class rule.** A fail-closed identity gate needs a test that runs it as EVERY+shipped identity. An id duplicated in a build spec that cannot import the+constant needs a parity test, or it drifts silently. A module a runtime loads by+NAME is invisible to a freezer: assert it in the built artifact, not in the+source.++## BUG-223: every public macOS download was ad-hoc signed — the first launch was blocked and every update forgot every grant (HIGH, FIXED IN CODE 2026-10-01; signing still needs the maintainer's Apple account)++> **Superseded in part by BUG-225 (2026-10-02).** The signing finding stands (a Developer ID+> signature is what lets grants persist across updates; the path has still never+> run). References to the re-ask explanation note ("macOS treats the app as new")+> describe the removed `identity_reset` note. The history below is kept as+> written.++**Symptom.** The `.dmg` behind the README's macOS link opens with "Apple cannot+check it for malicious software", and after each update the app asks for every+permission again.++**Evidence.** The v2.5.0 "Desktop installers" run, macOS arm64 job, printed:++ NOTICE: APPLE_SIGNING_IDENTITY is not set - ad-hoc signing this build. It is+ NOT notarized; macOS will refuse the first double-click ...+ codesign --force --deep -s - .../Personal Jarvis.app+ NOTICE: this build is ad-hoc signed and unnotarized - suitable for local+ testing, not for public download.++and that build is the published asset.++**Cause, two layers.**++1. No Developer ID identity is configured: that needs an Apple Developer Program+ membership and its credentials, which only the maintainer can provide.+2. Configuring it would not have worked. The workflow passed+ `APPLE_CERTIFICATE_P12_BASE64` / `APPLE_CERTIFICATE_PASSWORD` to `build.sh`,+ which never read them; a GitHub runner starts with an empty keychain, so+ `codesign --sign "Developer ID Application: ..."` could only fail.++An ad-hoc signature is a hash of the app's bytes, and macOS pins every privacy+grant to it: each release is a stranger and its grants are gone (BUG-083,+BUG-217). A Developer ID signature gives the app one identity — Team ID plus+bundle id — across versions, so its grants can persist. (BUG-218 calls the+`.dmg` build "notarized": it is built to be, but every image published so far is+ad-hoc.)++**Fix.** `packaging/macos/build.sh` imports the certificate into a throw-away+keychain when both secrets are present, reads the signing identity from it when+`APPLE_SIGNING_IDENTITY` is not given, and does all of that BEFORE the web bundle+and the ~12-minute freeze, so a certificate that cannot be used fails in+seconds. An exit trap removes the decoded certificate file, puts the user+keychain search list back (captured before the throw-away keychain is created)+and deletes the keychain — also after a failed import. No secret reaches the+log. Without secrets nothing changes. **Still open, by nature:** the Apple+secrets (five required, `APPLE_SIGNING_IDENTITY` optional;+`docs/desktop-installers.md` §4) have to be added before a build can be signed+and notarized, and that path has never run.++**Guards.** `tests/unit/packaging/test_macos_build_script.py` rehearses the+script with `DRY_RUN=1` in a scratch copy of the layout (unchanged ad-hoc path+without secrets, import order, no secret in the output, early refusal) and runs+the REAL import branch against a stand-in `security` command: call order, the+identity read back from the certificate, search list restored and keychain+deleted on success and on failure, no certificate file left behind.++**Verification.** Off a Mac only: `bash -n`, ShellCheck `-S style`, the tests+above. They were also run under GNU bash 3.2.39 — the macOS shell's series (macOS+itself ships 3.2.57), taken from an old Ubuntu package because this sandbox has+neither a Mac nor Docker: `scripts/ci/check_shell_bash32.py --require` parses+every tracked script, and the 12 build-script tests execute `build.sh` under it.+Not run: a real keychain, `codesign`, `notarytool`, `stapler`, or anything on+macOS itself.++## BUG-224: macOS asked for Music and Spotify control — and opened both apps — for a feature that is off (MEDIUM, FIXED 2026-10-01, unit-tested only)++> **Superseded by BUG-225 (2026-10-02).** `wanted`,+> `features[...].active`, `active_features()`, the "Optional" tag, the banner's+> "Not now" and the refresh event no longer exist. The over-asking they patched is+> removed at the root: a feature the user has not switched on never touches its+> permission (principle 7), and Automation is asked only by switching "Mute music+> while dictating" on. The history below is kept as written.++**Symptom (from the code paths of BUG-217's guided flow; not yet observed on a+Mac).** "Set up everything" and the app-wide banner demanded the Automation+(Music & Spotify) permission on every Mac — Music ships with macOS — started+Music (and Spotify, when installed) hidden to show the consent dialog, and kept+the banner on screen until it was answered, although "Mute music while+dictating" is opt-in and off by default.++**Cause.** `FEATURE_REQUIREMENTS` marked every permission needed by some+feature as missing, whether or not the user had turned that feature on.++**Fix.** The snapshot carries the policy: `features[...].active` and+`permissions[...].wanted` (a feature the user has turned on needs it).+`permissions.active_features(config)` switches `audio_ducking` off while+`[ducking].enabled` is false; the routes derive it from the live configuration+and hand it to every operation, so the status and each request/reset/open+response agree. The banner, the guided "Set up everything" flow and the+Settings poll consider only wanted rows; Settings still lists every row, with+an "Optional" tag, so it can be allowed by hand. The banner also gained+"Not now": per row, expiring after a week (re-read at every status refresh, so+a window that stays open for days still brings it back), and a row that turns up+later (a feature switched on afterwards) shows again; when the browser storage+refuses the write the choice is kept in memory for that window. Switching "Mute+music" on or off asks every open permission view to re-read the status, so the+Automation row follows the switch without waiting for a focus event. The "macOS+treats the app as new" note retires when the WANTED grants are back — an+Automation row nobody asked for no longer keeps it alive.++**Guards.** `tests/unit/platform/test_permissions.py` (policy, shared+permissions stay wanted, operations report the same policy, the note retires),+`tests/unit/ui/web/test_permissions_routes.py`, `usePermissions.test.tsx`+(an optional row does not poll), `useMuteMusic.test.tsx`,+`PermissionsAlertBanner.test.tsx` (expiry on refresh, unwritable storage, a+restart that stays visible), `PermissionsPanel.test.tsx`,+`src/lib/permissionsBannerDismissal.test.ts`.++**Verification.** Unit tests with faked native frameworks, vitest, a production+build and a light/dark look at the banner and the rows in Chromium on Linux.+Nothing was run in the macOS desktop app.+++---++## BUG-225: macOS was never asked — every protected feature refused behind the app's own permission check, so a banner, a wizard and a restart machine grew around the missing dialog (HIGH, FIXED IN CODE 2026-10-02; not yet exercised on a physical Mac)++**Symptom (class: a preflight wall in front of the OS ask).** On a Mac that had+never answered a dialog, the wake word was dead, dictation said microphone access+was "not ready", computer use and global shortcuts refused, and no macOS dialog+ever appeared from using the feature. The only road to a dialog was the app's own+UI: an app-wide banner, **Set up everything** in Settings, and an onboarding step.+The same wall produced the reports of BUG-159, BUG-161, BUG-222 and BUG-224: a+banner that stayed although the switch was on, features dead for the whole session+with every grant present, a whole surface disabled by one wrong identity constant,+and Music and Spotify opened hidden for a feature that was off. The user's own+words quoted in the history ("the permissions are extremely annoying") describe the+result.++**Cause.** `SystemPermissionPort.runtime_access_granted()` was true only for a+stable bundle identity AND an already-granted probe, and every feature path asked it+before touching the OS API (`audio/capture.py`, `cu/actuate/base.py`,+`cu/capture.py`, `trigger/backends/quartz.py`, `platform/window_state.py`,+`screen_context`, `vision/*`, dictation insert, the voice activation gate). For a+permission in `not_determined` the answer was no, so the feature raised before the+microphone, the tap or the capture was opened and macOS never got the chance to show+its own dialog. The frozen plan said the opposite (AD-13: probe at first use, degrade,+never hard-block); the shipped code inverted it on 2026-07-15 without a recorded+decision (reconstruction in `docs/macos-permissions.md` section 2). Each later layer+repaired a symptom of the wall instead of removing it: banner, dead-Allow fixes, sticky+restart flag, identity-reset note, wizard with auto-restart, Automation consent file,+`wanted` flag, "Not now". The wall also cost time on hot paths (per-frame, per-keystroke+and per-0.25 s probes; a tap callback that overran its deadline and was disabled).++**Fix (stages, all revertible).**++- `jarvis/platform/permission_service.py` is the single just-in-time layer: `check`+ (silent, never prompts) and `ensure` / `ensure_async` / `ensure_all` (interactive, only+ from a user gesture), one coalesced episode per (pane family, feature), a backend+ watcher that publishes `PermissionResolved` on a grant, and the `PermissionNeeded` /+ `PermissionResolved` events (AP-4 parity). Off macOS it returns NOT_REQUIRED before+ touching the port. Consumers receive it through the `PermissionGate` protocol.+- Features ask at their gesture: microphone at dictation, push-to-talk, a voice session,+ the wake-word switch and the mic self-test; Screen Recording at the first+ user-started capture; Accessibility when Jarvis first types, clicks or focuses;+ Input Monitoring when the user saves a global shortcut (a background listener has no+ "on use" moment; `PUT /api/settings/keybinds` asks, the onboarding Call-shortcut click asks+ once); Automation when the user switches "Mute music while dictating" on with a player+ running. Helpers `check()` and+ degrade; the computer-use engine keeps one silent Screen Recording gate and pauses+ while a macOS consent window is frontmost.+- Silent-failure traps are checked at the source: a flat wallpaper-only frame while the+ state claims granted, five seconds of exact zeros from the microphone while granted.+- Deleted: the banner and its dismissal store, the wizard and polling, the refresh+ event, the onboarding `permissions` step, `features` / `wanted` / `active` /+ `identity_reset` / `restart_required` / `foreground` in the snapshot, the Automation+ consent file and hidden launch, the identity-reset marker. Packaging got one usage-string+ table and lost the camera, speech and system-administration keys.+- AP-35 and ADR-0038 record the rule; `docs/macos-permissions.md` is the design, the+ evidence table and the manual Mac checklist.++**Prevention (AP-35).** A feature asks the OS at first use from a user gesture through+the service. No code path may refuse because our own preflight says "not granted"+before the OS was asked, and none may act on a permission the OS has not granted+(`EnsureResult.granted` only for GRANTED / NOT_REQUIRED; a native request's return value+is never evidence). Nothing is asked at launch (boot rule), denied is a stable state with+one toast and one click to the pane, identity decides who may ask and reset but not whether a feature may+act, an opt-in feature owns its permission, and an agent never answers a system dialog+(routine triggers exclude both permission events; no agent tool exposes ensure, request,+open-settings or reset). Review rule: a new macOS-gated feature that adds its own+"is it granted" refusal ahead of the OS ask, a banner, a wizard or a persisted "asked"+flag is this bug again.++**Guards.** `tests/contract/test_permission_service_contract.py` (scenario table on a+macOS-shaped and a non-macOS host), `tests/unit/platform/test_permission_service.py`,+`test_permission_service_hardening.py` and `test_permission_service_status_helpers.py`+(episodes, cooldowns, no second native request), `tests/fakes/fake_tcc.py` with+`tests/unit/platform/test_fake_tcc.py` (a stateful TCC simulator with an ordered call+log), `tests/unit/platform/test_no_legacy_permission_api.py` (a ratchet: the deleted+wall, its readiness aggregate, the identity-reset marker and the Automation consent+file must not return to `jarvis/`, `scripts/` or `.github/`),+`tests/unit/platform/test_permission_characterization.py` (what must survive; its last+test fails if a `test_legacy_*` test, one that would pin the removed wall, comes back),+`tests/unit/platform/test_permission_agent_boundary.py` and+`tests/unit/cu/test_permission_not_agent_exposed.py` (no agent-facing tool),+`tests/unit/platform/test_screen_access.py` and `tests/unit/cu/test_capture_permissions.py`+(a wallpaper-only frame is refused; a failed use is reported),+`tests/unit/speech/test_voice_permission_jit.py` (first press makes exactly one+microphone request, a denied press adds none, boot with every permission undecided asks+nothing, an upgrader sees zero cards, a non-macOS host consults nothing),+`tests/unit/audio/test_capture_permission_gate.py` (the microphone is asked once at open,+no per-frame probe), `tests/unit/audio/test_ducking_permissions.py` (only switching on+asks), `tests/unit/dictation/test_insert_permission.py`,+`tests/unit/trigger/test_quartz_jit_permissions.py` (no tap before the preflight is true),+`tests/unit/screen_context/test_service_permissions.py`,+`tests/unit/core/test_permission_events.py` (event vocabulary),+`tests/unit/ui/web/test_permissions_routes.py` and `test_permissions_snapshot.py`+(snapshot v2 never prompts), `tests/unit/ui/test_desktop_macos_permission_gate.py`,+`tests/unit/ci/test_macos_desktop_permission_step.py` (the macOS lane's permission+scripts run against FakeTCC so a step cannot rot into one that always passes), and the+frontend `permissionToast.test.ts` (the toast planner; the earlier card, inline-note and+Privacy-page tests were deleted with their UI, see the note below).++**Follow-up note (2026-10-02, UI reset).** The custom UI this fix first shipped (a floating card,+inline notes in five places, a Shortcuts status note and tip, the Settings > Privacy page and its+"Ask again") was judged unfit by the user and deleted: macOS shows its own dialog and the app adds+ONE toast with one action after a user-started use failed (`PermissionNeeded`, `origin="user"`,+`phase="blocked"`, owner window, once per episode and again on the next try; the wake word tells a denied microphone once per+session). The service, routes, snapshot v2, events and the boot rule are unchanged. Input Monitoring+is asked when a shortcut is saved; the way back from a stuck "denied" is the switch in System+Settings or the local `jarvis permissions reset <permission>` (macOS only; the HTTP reset route+still refuses scripts). The Info.plist strings became target-neutral and gained German and+Spanish `InfoPlist.strings` in both bundles. Details: ADR-0038 "Amendment: the UI is reduced to a+toast". Prevention addition: a new permission surface of our own around the OS dialog (card, note,+status page, up-front screen) is this bug's UI twin again. Guards added:+`tests/unit/ui/web/test_keybinds_input_monitoring_ask.py`,+`tests/unit/cli_ctl/test_commands_permissions.py` (reset), `tests/unit/packaging/test_macos_privacy_strings.py`+(localisations) and `tests/unit/ci/test_check_frozen_macos_app.py`.++**Verification.** Fake-framework unit and contract tests, vitest, Linux static gates, and+macOS CI runners for the packaging and frozen-app probe (ad-hoc signed; a runner is not a+user's Mac: it pre-grants TCC to its tools and shows no dialog). **Not verified, because+nothing ran on a physical Mac:** every real dialog and its wording, whether a running+process sees a new Screen Recording grant, hold-key semantics, the notarized build, macOS+26 and 27, the second dialog in the embedded WebView, and the Appshot both-Option+permission need. The rows to close these are in `docs/macos-permissions.md` section 7.++**Related.** BUG-058, BUG-083, BUG-159, BUG-161, BUG-217, BUG-222, BUG-223, BUG-224+(each carries a "superseded" note), ADR-0038, `docs/os-parity.md`,+`docs/product/privacy-safety-and-support/permissions.md`.+++ ## BUG-227: "send Jarvis Scout a message" found no agent when speech misheard the name (HIGH, FIXED 2026-10-02)++ **Symptom.** On a voice call the user asked Jarvis to message their agent+ Jarvis-Scout. Speech recognition delivered "the Java Scout and Quick Meshes";+ Jarvis answered "I couldn't find agents with those names in the open+ workspaces" and did nothing. The user's own later retelling was transcribed as+ "Jarvis Code" — the same name garbled a third way.++ **Cause.** Two gaps. (1) Every agent lookup compared strings exactly:+ `Roster.resolve` (id, case-insensitive name, slug) and the coding-pane+ resolver in `agentic_ide/orchestration.py` (exact or same word set), so any+ misheard spelling was "unknown". (2) The live backend's instructions only+ described `workspace-orchestrate`, so a request naming a Jarvis agent went to+ the coding-pane tool, which knows nothing about the team and answered "nothing+ open matches" — with no pointer to `delegate_to_agent` / `message_agent`.++ **Fix.** `jarvis/core/spoken_names.py` resolves a spoken name with+ normalization, aliases, Jaro-Winkler and Cologne phonetics, plus a small+ coding-context bonus, and returns act / ask / none; every resolution is logged+ (`name resolution [surface]: heard=... -> ... score=... method=...`).+ `jarvis/society/agent_names.py` applies it to the roster (exact matches first,+ so ids and REST paths are unchanged; title, role and user aliases stored as+ `agent_aliases:<id>` in `society_meta`). `delegate_to_agent`, `society_status`+ and the message tools use it: a close name returns `needs_clarification` with a+ "did you mean" question, an unknown one lists the available agents and says+ when it names a coding pane instead. `workspace-orchestrate` resolves misheard+ custom pane names the same way (positions stay exact) and, when a name is no+ pane but a Jarvis agent, says so in `jarvis_agent`. Guards:+ `tests/unit/core/test_spoken_names.py`, `tests/unit/society/test_agent_names.py`,+ `tests/unit/plugins/tool/test_delegate_to_agent.py`.++ ## BUG-228: an appshot photographed only the mascot or the Jarvis bar, not the app window (MEDIUM, FIXED 2026-10-02)++ **Symptom.** "Take an appshot" during a voice call sometimes sent the model a+ small square of the mascot instead of the window the person was working in.+ The log showed `appshot: active window 288x288 via tool -> turn` right after+ a normal 1280x696 one.++ **Cause.** An appshot captures the foreground window. A click on the mascot or+ the bar (to talk, mute or hang up) gives that small topmost `JarvisOrb` Tk+ overlay the Windows focus, so `GetForegroundWindow` returned the overlay and+ the capture targeted its 288x288 rectangle.++ **Fix.** `window_state.foreground_app_window()` looks past this process's own+ overlays (tool, non-activating or capture-excluded windows) and walks down+ the Z-order to the first real app window under them — the window the person+ used last. It steps over the taskbar, which sits between the overlays and the+ apps, and returns `None` at the wallpaper so the capture falls back to the+ monitor. The Screen Context window probe reads this instead of the raw+ foreground window. macOS and X11 need no walk: their probes never report the+ floating overlays. Guards: `tests/unit/platform/test_foreground_app_window.py`,+ `tests/unit/screen_context/test_ports.py`.++ ## BUG-229: a mission killed by an app restart stayed "running" for 37 minutes, then failed without an artifact (MEDIUM, FIXED 2026-10-02)++ **Symptom.** An artifact build (a GitHub-stars history dashboard, mission+ `01a0fcc3`) showed as running, then ended as `crash_recovery` /+ Failed 38 minutes later with no artifact and no partial output.++ **Cause.** The desktop app process was ended without a shutdown 85 s after+ the worker started (15:19:40; no crash record, the next launcher started at+ 15:19:44). The Claude worker died with it before writing any file. The new+ instance's recovery sweep then judged the mission only by its timestamps: its+ last heartbeat was younger than `RECOVERY_STALE_AFTER_MS` (30 min), so it was+ "presumed owned by a live instance" and skipped on every sweep — although no+ process was running it any more. The re-sweep finally failed it at 15:56:42.++ **Fix.** The orchestrator stamps its process identity (pid + process start+ time) next to every mission heartbeat, starting the moment `run_mission`+ begins (`missions.owner_pid` / `owner_start_ms`, migrated in place).+ `startup_recover` asks `jarvis/missions/ownership.py` whether that owner is+ alive: a provably dead owner (or a pid now reused by another process) is+ swept at once with an `error_detail` naming the exited process. An alive or+ unknown owner keeps the old freshness guard, so a second instance still never+ sweeps a mission a live first instance is running. The restart that killed+ the worker is outside this fix. Guard: `tests/missions/test_recovery_owner.py`.++ ## BUG-230: the mascot and the bar showed up inside appshots and screenshots (MEDIUM, FIXED 2026-10-02)++ **Symptom.** An appshot of the Personal Jarvis window, and a full-screen+ capture, both contained the floating mascot on top of the content, although+ the overlays are meant to stay out of every capture.++ **Cause.** The overlays call `exclude_tk_window_from_capture` before their+ first show. Tk creates a toplevel's outer window only when it is first mapped,+ so `GetParent(winfo_id())` was 0, the display affinity landed on the inner+ child window, and the real outer window kept affinity 0 (measured on the live+ `JarvisOrb`: `GetWindowDisplayAffinity` = 0x0).++ **Fix.** `jarvis/platform/capture_exclusion.py` no longer targets the inner+ child and additionally re-applies `WDA_EXCLUDEFROMCAPTURE` on every `<Map>` of+ the toplevel (bound with `add="+"`, child-widget maps ignored). Checked with a+ real Tk root and Toplevel: 0x11 after the first map and after withdraw/show.+ Side effect: the overlays also vanish from other capture tools (ShareX, OBS),+ which is the documented intent of the module. Guard:+ `tests/unit/platform/test_capture_exclusion.py`.diff --cc docs/appshots.mdindex 62109fb82a,d2f894ad66..518f6813e9--- a/docs/appshots.md+++ b/docs/appshots.md@@@ -64,13 -114,14 +114,14 @@@ original any-order behaviour| | Windows | macOS | Linux/X11 | Wayland / headless ||---|---|---|---|---|-| Both-Alt shortcut | `GetAsyncKeyState` (AltGr counts as right Alt) | `CGEventSourceKeyState`, needs the Input Monitoring grant | `XQueryKeymap` via python-xlib | Unavailable, reason shown on the page; voice and the button still work where capture works |+| Both-Alt shortcut | `GetAsyncKeyState` (AltGr counts as right Alt) | `CGEventSourceKeyState`; whether this read needs the Input Monitoring grant is **unverified** (not measured on a Mac), so the page shows no Input Monitoring row for it | `XQueryKeymap` via python-xlib | Unavailable, reason shown on the page; voice and the button still work where capture works |- | Other shortcuts | Shared hotkey backends (`jarvis/trigger/backends`) | same | same | same as above |+ | Other shortcuts (incl. the area shortcut) | Shared hotkey backends (`jarvis/trigger/backends`) | same | same | same as above |+ | Area picker | PySide6 overlay; a global Esc also cancels because Windows may not hand it keyboard focus until the first click | PySide6 overlay | PySide6 overlay | Unavailable, reason shown on the page; the window appshot still works || Flash + thumbnail | PySide6 overlay, excluded from capture | PySide6 overlay | PySide6 overlay | No overlay; the appshot is still taken where capture works |-| Capture | Screen Context engine | Needs Screen Recording | X11 | Honest refusal |+| Capture | Screen Context engine | Needs Screen Recording; macOS asks for it at the first appshot you take | X11 | Honest refusal |Only the instance that owns ambient duties (the default app, not the dev- instance) arms the shortcut.+ instance) arms the shortcuts.## Codediff --cc docs/os-parity.mdindex 67a0782935,323a9b1884..d0fb3e8469--- a/docs/os-parity.md+++ b/docs/os-parity.md@@@ -926,11 -638,10 +926,11 @@@ implementations, not stubs| Area | Verdict ||---|---|-| Computer-Use / desktop actions (click, type, hotkey, scroll, drag, windows, apps, screenshots, UI trees) | Full per-OS backends (Win32/UIA, Quartz/AX, xdotool/AT-SPI); honest degradation on Wayland/headless/missing TCC grants |-| On-demand Screen Context | One-shot capture is wired into the production brain on Windows, macOS, and Linux/X11; UIA/AX/AT-SPI text is source-filtered, the indicator precedes capture, and Wayland/headless/missing grants refuse honestly |-| Appshots (front-window capture on a shortcut, button or request) | Capture, privacy and delivery are OS-neutral (Screen Context engine, `jarvis/appshot`). The two-sided shortcuts (both Alt, both Shift, both Ctrl) read key state per OS: Windows `GetAsyncKeyState`, macOS `CGEventSourceKeyState` (Input Monitoring grant), Linux/X11 `XQueryKeymap`; Wayland/headless report it unavailable on the Appshots page. The flash and the area picker (both Shift keys, drag a rectangle) are PySide6 overlays where one can run; Wayland/headless report the area picker unavailable. Verified live on Windows only; see `docs/appshots.md` |-| Voice / audio (capture, playback, VAD, wake, STT, TTS, realtime) | Clean; headless disables voice honestly; WASAPI logic is inert-by-data off Windows |+| Computer-Use / desktop actions (click, type, hotkey, scroll, drag, windows, apps, screenshots, UI trees) | Full per-OS backends (Win32/UIA, Quartz/AX, xdotool/AT-SPI); honest degradation on Wayland/headless/missing TCC grants. macOS: Accessibility is asked when Jarvis first types, clicks or focuses a window, Screen Recording at the first user-started capture; AX reads never prompt, and nothing is asked at launch |+| On-demand Screen Context | One-shot capture is wired into the production brain on Windows, macOS, and Linux/X11; UIA/AX/AT-SPI text is source-filtered, the indicator precedes capture, and Wayland/headless/missing grants refuse honestly (on macOS a flat wallpaper-only frame is refused, never delivered) |- | Appshots (front-window capture on a shortcut, button or request) | Capture, privacy and delivery are OS-neutral (Screen Context engine, `jarvis/appshot`). The both-Alt shortcut reads key state per OS: Windows `GetAsyncKeyState`, macOS `CGEventSourceKeyState` (whether this read needs the Input Monitoring grant is UNVERIFIED; the repo contradicts itself and no Mac measured it, so it is not an Input Monitoring row — see `docs/macos-permissions.md`), Linux/X11 `XQueryKeymap`; Wayland/headless report it unavailable on the Appshots page. The flash is the PySide6 overlay where one can run. Verified live on Windows only; see `docs/appshots.md` |++| Appshots (front-window capture on a shortcut, button or request) | Capture, privacy and delivery are OS-neutral (Screen Context engine, `jarvis/appshot`). The two-sided shortcuts (both Alt, both Shift, both Ctrl) read key state per OS: Windows `GetAsyncKeyState`, macOS `CGEventSourceKeyState` (whether this read needs the Input Monitoring grant is UNVERIFIED; the repo contradicts itself and no Mac measured it, so it is not an Input Monitoring row — see `docs/macos-permissions.md`), Linux/X11 `XQueryKeymap`; Wayland/headless report it unavailable on the Appshots page. The flash and the area picker (both Shift keys, drag a rectangle) are PySide6 overlays where one can run; Wayland/headless report the area picker unavailable. Verified live on Windows only; see `docs/appshots.md` |+| Voice / audio (capture, playback, VAD, wake, STT, TTS, realtime) | Clean; headless disables voice honestly; WASAPI logic is inert-by-data off Windows. macOS microphone: asked at the first dictation, push-to-talk, voice session, wake-word switch or mic self-test, never at launch (2026-10-02 pass) |+| macOS privacy permissions (TCC) | One just-in-time service (`jarvis/platform/permission_service.py`, AP-35, ADR-0038): `check` is silent, `ensure` asks only from a user gesture and only from the installed app (or after a confirmation naming the grantee); Windows and Linux return NOT_REQUIRED before touching anything. The app draws nothing around macOS's dialog; after a denied user-started use it shows one toast with one action. Verified against fake frameworks and runner packaging probes only, not on a physical Mac (`docs/macos-permissions.md` section 7) || Core (launcher, config, keyring, restart, autostart, tray, elevation, paths) | Clean; per-OS autostart (Registry / LaunchAgent / XDG `.desktop`), keyring falls back to a 0600 file on headless hosts || Data / agents (wiki, contacts, telephony, sessions, missions, skills, self-mod, channels, MCP) | Clean; mission workers run on POSIX with a real process-group reaper || Agent society hands (own shell, browser via browser-use, learned skills) | Shell: local subprocess in the agent's workspace on every OS (Git Bash/PowerShell/bash/sh pick as the chat's folder tools), no container by decision. Browser: browser-use lives in a managed venv under the data dir (its pins collide with the app's), installed on demand — `uv`/`venv`, a 3.11–3.13 interpreter preferred, Chromium downloaded once; headless runs need no display, so a headless Linux box runs agents' browsers; the headed login session needs a display (409 without one is the follow-up); attach mode needs a running Chrome with `--remote-debugging-port`. Learning is pure files + the brain, OS-neutral |diff --cc jarvis/__init__.pyindex 16a3096b9c,2b7efeb011..fc50eb28e4--- a/jarvis/__init__.py+++ b/jarvis/__init__.py@@@ -1,3 -1,11 +1,11 @@@"""Personal Jarvis — a voice-driven, cross-platform meta-orchestrator."""-__version__ = "2.3.2"+__version__ = "2.7.1"++ # Every httpx client in the process shares one parsed CA bundle instead of+ # re-parsing it (~200 ms of CPU) per client. Patches httpx lazily, the moment+ # it is first imported; importing ``jarvis`` itself still loads nothing heavy.+ from jarvis.core.shared_tls import install_when_imported as _install_shared_tls++ _install_shared_tls()+ del _install_shared_tlsdiff --cc jarvis/agentic_ide/orchestration.pyindex b2ebcec88b,0662b6572b..ed9be2e432--- a/jarvis/agentic_ide/orchestration.py+++ b/jarvis/agentic_ide/orchestration.py@@@ -378,9 -408,9 +408,9 @@@ class WorkspaceOrchestrator}try:count = int(args.get("count") or 1)- except (TypeError, ValueError):+ except (TypeError, ValueError): # a malformed count falls back to one terminalcount = 1- count = max(1, min(count, MAX_TERMINALS))+ count = max(1, min(count, MAX_PANES_PER_REQUEST))name = str(args.get("name") or "").strip()mixed = args.get("agents")if isinstance(mixed, list) and mixed:@@@ -728,9 -758,9 +758,9 @@@}try:count = int(entry.get("count") or 1)- except (TypeError, ValueError):+ except (TypeError, ValueError): # a malformed count falls back to one terminalcount = 1- groups.append((cli, max(1, min(count, MAX_TERMINALS))))+ groups.append((cli, max(1, min(count, MAX_PANES_PER_REQUEST))))return groups or [(_default_cli(), 1)]async def _brief(diff --cc jarvis/appshot/gesture.pyindex fcbdc10551,234ff1c320..53926d3407--- a/jarvis/appshot/gesture.py+++ b/jarvis/appshot/gesture.py@@@ -1,19 -1,16 +1,21 @@@- """The "both Alt keys at once" gesture.-- The shared hotkey backends fold left and right Alt into one token (the- Windows library knows no difference), so a chord of the two Alt keys cannot be- expressed there. This module watches exactly that gesture with the cheapest- primitive each OS offers — a key-state read every 50 ms, no hook, no tap:-- * Windows: ``GetAsyncKeyState`` on ``VK_LMENU`` / ``VK_RMENU`` (AltGr raises- ``VK_RMENU`` too, so the gesture works on AltGr layouts).- * macOS: ``CGEventSourceKeyState`` on the left/right Option key codes. Whether- this read needs a privacy grant (Input Monitoring) is UNVERIFIED: the repo- contradicts itself (``CGEventSourceFlagsState`` is documented in- ``jarvis/trigger/hotkey.py`` as needing none) and neither was measured on a- Mac. It is therefore not treated as an Input Monitoring feature and never- triggers a permission request; if the gesture does nothing the status text- (``jarvis/appshot/hotkey.py``) points to another key combination.+ """The "both X keys at once" gestures: both Alt, both Shift, both Ctrl.++ The shared hotkey backends fold the left and right modifier into one token+ (the Windows library knows no difference), so a chord of the two Alt (or+ Shift, or Ctrl) keys cannot be expressed there. This module watches exactly+ that gesture with the cheapest primitive each OS offers — a key-state read+ every 50 ms, no hook, no tap:++ * Windows: ``GetAsyncKeyState`` on the left/right virtual keys (AltGr raises+ ``VK_RMENU`` too, so the Alt gesture works on AltGr layouts).+ * macOS: ``CGEventSourceKeyState`` on the left/right key codes (Option, Shift,- Control). Needs the same Input Monitoring grant as every other global- shortcut; without it the read stays false and nothing fires.++ Control). Whether this read needs a privacy grant (Input Monitoring) is++ UNVERIFIED: the repo contradicts itself (``CGEventSourceFlagsState`` is++ documented in ``jarvis/trigger/hotkey.py`` as needing none) and neither was++ measured on a Mac. It is therefore not treated as an Input Monitoring++ feature and never triggers a permission request; if the gesture does nothing++ the status text (``jarvis/appshot/hotkey.py``) points to another key++ combination.* Linux/X11: ``XQueryKeymap`` through python-xlib (pynput's own dependency).* Wayland, headless, missing packages: :func:`make_probe` returns ``None``with the reason, and the caller reports the shortcut as unavailable.diff --cc jarvis/appshot/hotkey.pyindex 30f5a44b4d,03511e2c75..58a51351b1--- a/jarvis/appshot/hotkey.py+++ b/jarvis/appshot/hotkey.py@@@ -30,28 -61,25 +61,41 @@@ class ShortcutStatusreturn {"hotkey": self.hotkey, "armed": self.armed, "detail": self.detail}+#: Status text for the both-Option gesture on a Mac. Its permission need is+#: UNVERIFIED (see ``jarvis.appshot.gesture``), so the hint names no permission:+#: sending someone to grant one it may not need is worse than saying nothing.+BOTH_OPTION_MAC_NOTE = (+ "If the both-Option shortcut does nothing on this Mac, pick a key "+ "combination instead."+)+++def _both_alt_note() -> str:+ """The macOS-only hint that goes with an armed both-Option gesture."""+ from jarvis.platform import detect_platform # noqa: PLC0415++ return BOTH_OPTION_MAC_NOTE if detect_platform() == "darwin" else ""++def normalize_hotkey(value: str) -> str:- """Canonical spelling: lower case, no spaces, both-Alt aliases folded."""+ """Canonical spelling: lower case, no spaces, both-keys aliases folded."""combo = "+".join(part.strip().lower() for part in str(value or "").split("+") if part.strip())- if combo in {"alt+alt", "left_alt+right_alt", "right_alt+left_alt", "alt+altgr", "altgr+alt"}:- return BOTH_ALT- return combo+ return _GESTURE_ALIASES.get(combo, combo)+++ def is_gesture(hotkey: str) -> bool:+ """A both-keys gesture, not a combo for the shared hotkey backends."""+ from jarvis.appshot.gesture import GESTURES # noqa: PLC0415++ return hotkey in GESTURES+++ def configured_hotkeys(block: Any) -> dict[str, str]:+ """Scope → normalized shortcut from an ``[appshot]`` config block."""+ return {+ scope: normalize_hotkey(str(getattr(block, key, "") or ""))+ for scope, key in SCOPE_KEYS.items()+ }class AppshotShortcut:@@@ -122,18 -177,29 +193,30 @@@with contextlib.suppress(asyncio.CancelledError):await task- async def _arm_both_alt(self) -> ShortcutStatus:- from jarvis.appshot.gesture import BothAltWatcher, make_probe # noqa: PLC0415+ async def _arm_gesture(self, scope: str, hotkey: str) -> ShortcutStatus:+ from jarvis.appshot.gesture import ( # noqa: PLC0415+ GESTURES,+ BothKeysWatcher,+ make_probe,+ together_window,+ )- probe, reason = await asyncio.to_thread(make_probe)+ family = GESTURES[hotkey]+ probe, reason = await asyncio.to_thread(make_probe, family)if probe is None:- return ShortcutStatus(hotkey=BOTH_ALT, armed=False, detail=reason)- watcher = BothAltWatcher(self._fire_threadsafe, probe=probe)+ return ShortcutStatus(hotkey=hotkey, armed=False, detail=reason)+ watcher = BothKeysWatcher(+ lambda: self._fire_threadsafe(scope),+ probe=probe,+ together_s=together_window(family),+ )watcher.start()- self._watcher = watcher- return ShortcutStatus(hotkey=BOTH_ALT, armed=True, detail=_both_alt_note())+ self._watchers.append(watcher)- return ShortcutStatus(hotkey=hotkey, armed=True)++ detail = _both_alt_note() if hotkey == BOTH_ALT else ""++ return ShortcutStatus(hotkey=hotkey, armed=True, detail=detail)- def _arm_combo(self, hotkey: str) -> ShortcutStatus:+ @staticmethod+ def _check_combo(hotkey: str) -> ShortcutStatus:from jarvis.platform.probes import has_hotkey # noqa: PLC0415from jarvis.trigger.hotkey import validate_hotkey # noqa: PLC0415diff --cc jarvis/brain/workspace_tool.pyindex b2a4436e13,d6293f703f..ed6c017acc--- a/jarvis/brain/workspace_tool.py+++ b/jarvis/brain/workspace_tool.py@@@ -36,11 -75,11 +75,13 @@@ class WorkspaceOrchestrationTool"remembers its resolves, so a slightly mistyped id still works); reuse it for ""retries. Explicit background targets never switch the visible workspace. ""Accepted means delivered, not completed; uncertain delivery must not be retried. "+ "The result returns asynchronously to this conversation; keep talking to the user "+ "instead of waiting or polling in a loop. ""After a proven pre-write refusal, resolve again for a fresh request_id ""before a new attempt. "- "Use context with the same IDs to inspect recorded results. No prompt rewriting is needed."+ "Use context with the same IDs to inspect recorded results. No prompt rewriting is needed. "+ "A prompt for create, open_workspace or send is a work order the agent carries "+ "out, never a read-only request unless the user asked for one (see prompt).")schema = {"type": "object",@@@ -159,11 -199,9 +206,12 @@@try:result = await self.gateway.run(args, trace_id=str(ctx.trace_id))except ValueError as exc:+ # Invalid arguments go back to the model as the tool error.return ToolResult(success=False, output=None, error=str(exc))+ finally:+ current_delegation_origin.reset(token)status = result.get("status")+ result = _point_at_jarvis_agent(args, result)return ToolResult(success=result.get("success") is not Falseand status not in {"uncertain", "unavailable", "stale_target", "not_accepted"},diff --cc jarvis/live/config.pyindex eea23f536f,172f78c423..c1fc3a3873--- a/jarvis/live/config.py+++ b/jarvis/live/config.py@@@ -2,10 -2,9 +2,11 @@@from __future__ import annotations+from typing import Literal+from pydantic import BaseModel, ConfigDict, Field+ from jarvis.core.agent_brief import AGENT_BRIEF_RULEfrom jarvis.live.product import PRODUCT_BRIEF@@@ -21,42 -20,19 +22,53 @@@ class LiveConfig(BaseModel)instructions: str = Field(default="", max_length=8000)backend_instructions: str = Field(default="", max_length=32000)configured: bool = False+ auth_mode: Literal["api_key", "chatgpt_subscription"] = "api_key"+ subscription_account_id: str = Field(default="", max_length=256)+ subscription_voice: str = "cove"+ subscription_backend_model: str = ""+ subscription_reasoning_effort: str = "medium"++ @property+ def provider_id(self) -> str:+ if self.auth_mode == "chatgpt_subscription":+ return "openai-live-subscription"+ return "openai-live"++ def for_session(self) -> LiveConfig:+ """Snapshot the selected mode without overwriting the other mode's settings."""+ if self.auth_mode == "api_key":+ return self.model_copy()+ return self.model_copy(update={+ "model": "gpt-live-1-codex",+ "voice": self.subscription_voice,+ "backend_model": self.subscription_backend_model,+ "reasoning_effort": self.subscription_reasoning_effort,+ })++ def backend_config(self, *, language: str, tools: list[dict]) -> dict:+ """Use the same Jarvis instructions and tools for client-managed reasoning."""+ effective = self.for_session().model_copy(update={"auth_mode": "api_key"})+ return effective.session_config(language=language, tools=tools)["delegation"]["responses"]- def session_config(self, *, language: str, tools: list[dict]) -> dict:+ def session_config(self, *, language: str, tools: list[dict], identity: str = "") -> dict:+ """The GPT-Live session; ``identity`` is ``jarvis.brain.identity.identity_block``.++ Empty ``identity`` (a contract check without app config) falls back to+ the nameless directive, never to the product name as the assistant's.+ """+ if self.auth_mode == "chatgpt_subscription":+ effective = self.for_session().model_copy(update={"auth_mode": "api_key"})- session = effective.session_config(language=language, tools=tools)++ session = effective.session_config(++ language=language, tools=tools, identity=identity++ )+ session["delegation"] = {"type": "client"}+ return sessionif not self.configured or not self.backend_model.strip():raise ValueError("Choose a GPT-Live thinking model in API Keys before starting voice.")+ if not identity:+ from jarvis.brain.identity import name_directive++ identity = name_directive("")backend: dict = {"model": self.backend_model,"instructions": (diff --cc jarvis/plugins/tool/delegate_to_agent.pyindex de8470d6b6,4fc3c4dea9..6469edd8c5--- a/jarvis/plugins/tool/delegate_to_agent.py+++ b/jarvis/plugins/tool/delegate_to_agent.py@@@ -23,8 -24,9 +24,10 @@@ import logginfrom collections.abc import Callablefrom typing import Any, Final+ from jarvis.core.agent_brief import AGENT_BRIEF_RULE+from jarvis.core.delegation import origin_metadatafrom jarvis.core.protocols import ExecutionContext, ToolResult+ from jarvis.society.agent_names import AgentLookup, coding_pane_hint, lookup_agentfrom jarvis.society.communication import REPLY_POLICY_SCHEMA, select_reply_policylog = logging.getLogger(__name__)@@@ -134,8 -151,11 +152,12 @@@ class DelegateToAgentTool"to the team'. Use when a background task fits the persistent team; leave `agent` ""empty to let the lead pick the agent whose hands fit the task. The agent works in ""the background; you acknowledge now and its result follows reply_policy. "+ "Stay available for conversation while it runs; completion is delivered asynchronously. ""Never for inventory/status questions or tasks the user wants done right here. "+ "Not for coding panes in the Agentic IDE (T1, or a named Claude Code / Codex "+ "session): those go through workspace-orchestrate. Pass the agent's name as heard; "+ "the app matches misheard names and, when unsure, returns needs_clarification with "+ "a question to ask before calling again. ""Turn the user's intent into an actionable brief: objective, known target, relevant ""context, scope, constraints and completion evidence. Do not merely paraphrase or ""invent facts. Include context and completion_criteria so the agent can act independently. "diff --cc jarvis/realtime/factory.pyindex b8122d9eac,6913041d45..a160c4a2cb--- a/jarvis/realtime/factory.py+++ b/jarvis/realtime/factory.py@@@ -364,13 -346,12 +370,16 @@@ async def realtime_prespawn_transports("configured voice mode.")return- for provider_id in _explicit_provider_ids(cfg):+ for position, provider_id in enumerate(_explicit_provider_ids(cfg)):try:- provider_cls = load(_GROUP, provider_id, protocol=RealtimeProvider)+ # Off the loop for the same reason as the warm above.+ provider_cls = await asyncio.to_thread(+ load, _GROUP, provider_id, protocol=RealtimeProvider+ )+ if position > 0 and not bool(+ getattr(provider_cls, "eager_warm_as_fallback", False)+ ):+ continueprespawn = getattr(provider_cls, "prespawn_transport", None)if callable(prespawn):await prespawn(cfg)diff --cc jarvis/society/agent_tools.pyindex 5ac693c98e,a1c9db05d3..8fe3a6f2a5--- a/jarvis/society/agent_tools.py+++ b/jarvis/society/agent_tools.py@@@ -219,10 -237,13 +237,17 @@@ class MessageAgentToolFailureReason.BLOCKED_BY_POLICY, "no success reply was requested")trace_id = parent.trace_id if parent is not None else None+ if caller.agent_id == rt.lead_id and parent is None:+ from jarvis.core.delegation import origin_metadata+ config = getattr(ctx, "config", None) or {}+ payload.update(origin_metadata(language=str(config.get("output_language") or "")))+ from jarvis.core.protocols import current_chat_turn++ turn = current_chat_turn.get()+ if turn is not None and turn.session_id:+ # Which of the caller's chats wrote it: the person's chat with the+ # agent shows only its own outgoing messages, never a conversation's.+ payload["from_session"] = turn.session_idenv = await rt.say(from_agent=caller.agent_id,to_agent=target.agent_id,diff --cc jarvis/society/chat_binding.pyindex 057e8e6125,30e64c4fcd..ba1c2c5a17--- a/jarvis/society/chat_binding.py+++ b/jarvis/society/chat_binding.py@@@ -77,45 -85,31 +85,58 @@@ def _workspace(cfg: Any, agent: AgentRereturn str(folder)- def ensure_session(svc: Any, cfg: Any, agent: AgentRecord) -> Any:- """The agent's canonical session, created or re-seated to the roster row."""+ def ensure_session(+ svc: Any,+ cfg: Any,+ agent: AgentRecord,+ *,+ counterpart: str = "",+ counterpart_name: str = "",+ ) -> Any:+ """The agent's session, created or re-seated to the roster row.++ Without ``counterpart`` this is the canonical chat, the one a person has+ with the agent. With it, it is the agent's own conversation with Jarvis or+ a teammate (``society:<agent>:with:<counterpart>``): same seat, workspace,+ approvals, tools and memory, but its turns never land in the person's chat.+ """from jarvis.agent_chat.effort import default_effort- from jarvis.agent_chat.permissions import ladder_key, normalize_permission+ from jarvis.agent_chat.permissions import (+ ladder_key,+ normalize_permission,+ society_mode_supported,+ stance_of,+ )from jarvis.agent_chat.service import resolve_runnerprovider, model, effort = pair_for(cfg, agent)+ runner = resolve_runner(provider, surface=SURFACE)+ legacy_mode = ""+ if agent.approval_mode is None:+ legacy_mode = normalize_permission(+ "jarvis", _CEILING_TO_MODE[str(agent.permission_ceiling)]+ )+ if legacy_mode not in ("plan", "read-only") and not society_mode_supported(+ runner, "ask"+ ):+ raise PermissionError(+ f"{runner} cannot provide an actionable approval for this legacy agent"+ )+ if agent.approval_mode is not None and not society_mode_supported(+ runner, str(agent.approval_mode)+ ):+ raise PermissionError(+ f"{runner} cannot provide an actionable approval for {agent.approval_mode}"+ )- session_id = agent.session_id+ session_id = conversation_session_id(agent.agent_id, counterpart)existing = svc.store.get_session(session_id)if existing is None:- ladder = ladder_key(SURFACE, resolve_runner(provider, surface=SURFACE))- mode = normalize_permission(ladder, _CEILING_TO_MODE[str(agent.permission_ceiling)])+ ladder = ladder_key(SURFACE, runner)+ if agent.approval_mode is None:+ # A pre-migration row keeps the old Jarvis ladder, including Plan.+ mode = legacy_mode+ else:+ mode = normalize_permission(ladder, str(agent.approval_mode))return svc.store.create_session(provider=provider,model=model,@@@ -167,47 -133,28 +192,80 @@@updates["account_id"] = agent.account_idif effort and existing.effort != effort:updates["effort"] = effort+ if existing.permission_mode != mode:+ updates["permission_mode"] = mode- if existing.title != agent.name:++ # Only the canonical chat follows the card name; a conversation chat keeps++ # its "<agent> · <counterpart>" title.++ if session_id == agent.session_id and existing.title != agent.name:+ updates["title"] = agent.name+ workspace = _workspace(cfg, agent)+ if existing.cwd != workspace:+ updates["cwd"] = workspaceif updates:svc.store.update_session(session_id, **updates)existing = svc.store.get_session(session_id)return existing+async def bind_society_session(svc: Any, session_id: str, *, routine_run: bool = False) -> Any:- """Apply the live roster ceiling before a Society session is used."""++ """Apply the live roster ceiling before a Society session is used.++++ Three session shapes belong to an agent: its canonical chat++ (``society:<agent>``), a scheduled run (``society:<agent>:routine:...``)++ and a conversation chat with Jarvis or a teammate++ (``society:<agent>:with:<counterpart>``).++ """+ from jarvis.agent_chat.service import SessionBusy++ from .runtime import current_runtime++ if svc.is_running(session_id):+ raise SessionBusy(session_id)+ runtime = current_runtime()- agent_id = session_id.removeprefix("society:").split(":routine:", 1)[0]++ agent_id = (++ session_id.removeprefix("society:")++ .split(":routine:", 1)[0]++ .split(PAIR_SESSION_MARKER, 1)[0]++ )+ agent = await runtime.roster.get(agent_id) if runtime is not None else None+ session = svc.store.get_session(session_id)+ if agent is None or session is None or session.surface != SURFACE:+ raise PermissionError("Society agent is unavailable")+ inactive = str(agent.state) != "active" or await runtime.store.kill_switch()+ if session_id.startswith(f"{agent.session_id}:routine:"):+ if not routine_run or inactive:+ raise PermissionError("Routine chat requires an active scheduled run")+ # Each scheduled run has its own explicitly pinned seat and permission+ # contract. The internal caller has revalidated its live owner.+ return session- if agent.session_id != session_id:++ counterpart = ""++ pair_prefix = agent.session_id + PAIR_SESSION_MARKER++ if session_id.startswith(pair_prefix):++ counterpart = session_id[len(pair_prefix):]++ if conversation_session_id(agent.agent_id, counterpart) != session_id:++ raise PermissionError("Society agent is unavailable")++ elif agent.session_id != session_id:+ raise PermissionError("Society agent is unavailable")+ if inactive:+ raise PermissionError("Society agent is paused or disabled")- return ensure_session(svc, runtime.config(), agent)++ return ensure_session(svc, runtime.config(), agent, counterpart=counterpart)+++ def _agent_busy(svc: Any, agent: AgentRecord) -> bool:+ """Whether the person's chat or a conversation chat of ``agent`` runs a turn.++ Messages wait until the agent is free, as they did when it had one chat:+ two message turns never share its seat, workspace and browser at once.+ Routine runs are background work and do not hold messages up.+ """+ if svc.is_running(agent.session_id):+ return True+ running = getattr(svc, "running_session_ids", None)+ if not callable(running):+ return False+ prefix = agent.session_id + PAIR_SESSION_MARKER+ return any(sid.startswith(prefix) for sid in running())+-def frame_incoming(env: SocietyEnvelope, sender_name: str) -> str:"""How a board envelope reads inside the receiving agent's chat."""kind = str(env.msg_type).lower()diff --cc jarvis/society/conversation.pyindex 4d8ee1ad39,d5219cb38e..0fd4c84fbe--- a/jarvis/society/conversation.py+++ b/jarvis/society/conversation.py@@@ -136,24 -110,28 +143,29 @@@ class ConversationArchiveif not words:return []limit = max(1, min(20, limit))+ prefix = session + ":"+ scope = "(m.session=? OR substr(m.session,1,?)=?)" if include_owned else "m.session=?"+ scope_args: tuple[Any, ...] = (+ (session, len(prefix), prefix) if include_owned else (session,)+ )with self._lock:+ self.open()if self.fts_available:expression = " OR ".join('"' + w + '"' for w in words[:32])- rows = self._db.execute(- "SELECT m.seq,m.kind,m.text FROM messages_fts f "+ sql = (+ "SELECT m.session,m.seq,m.kind,m.text FROM messages_fts f " # noqa: S608"JOIN messages m ON m.id=f.rowid WHERE messages_fts MATCH ? "- "AND m.session=? ORDER BY bm25(messages_fts),m.seq DESC LIMIT ?",- (expression, session, limit),- ).fetchall()+ f"AND {scope} ORDER BY bm25(messages_fts),m.seq DESC LIMIT ?"+ )+ rows = self._db.execute(sql, (expression, *scope_args, limit)).fetchall()else:- clauses = " OR ".join("instr(lower(text),?)>0" for _ in words[:32])- rows = self._db.execute(- "SELECT seq,kind,text FROM messages WHERE session=? AND (" # noqa: S608 - bound values- + clauses- + ") ORDER BY seq DESC LIMIT ?",- (session, *(w.lower() for w in words[:32]), limit),- ).fetchall()+ clauses = " OR ".join("instr(lower(m.text),?)>0" for _ in words[:32])+ sql = ( # scope and clauses are fixed SQL; every value is bound+ "SELECT m.session,m.seq,m.kind,m.text FROM messages m " # noqa: S608+ f"WHERE {scope} AND ({clauses}) ORDER BY m.seq DESC LIMIT ?"+ )+ words_lower = (w.lower() for w in words[:32])+ rows = self._db.execute(sql, (*scope_args, *words_lower, limit)).fetchall()return [{"seq": r["seq"],diff --cc jarvis/society/conversation_tool.pyindex 9a696ece0d,5c77aff1e0..b174f3e13e--- a/jarvis/society/conversation_tool.py+++ b/jarvis/society/conversation_tool.py@@@ -36,14 -37,14 +38,17 @@@ class ConversationRecallToolservice = self._runtime.chat_service()archive = self._runtime.conversationsif service is not None:- archive.ingest(session, service.store.list_events(session))+ events = await asyncio.to_thread(service.store.list_events, session)+ await asyncio.to_thread(archive.ingest, session, events)limit = max(1, min(20, int(args.get("limit") or 5)))if str(args.get("query") or "").strip():- hits = await asyncio.to_thread(archive.search, session, str(args["query"]), limit=limit)+ query = str(args["query"])- hits = archive.search(session, query, limit=limit, include_owned=True)++ hits = await asyncio.to_thread(++ archive.search, session, query, limit=limit, include_owned=True++ )return ToolResult(True, {"hits": hits})- events = archive.read(- session, after_seq=max(0, int(args.get("after_seq") or 0)), limit=limit+ events = await asyncio.to_thread(+ archive.read, session, after_seq=max(0, int(args.get("after_seq") or 0)), limit=limit)return ToolResult(True, {"events": events, "next_after_seq": events[-1]["seq"] if events else None}diff --cc jarvis/ui/web/agent_chat_routes.pyindex 3585b28226,1e74e04d0d..071b63d58f--- a/jarvis/ui/web/agent_chat_routes.py+++ b/jarvis/ui/web/agent_chat_routes.py@@@ -142,11 -136,19 +166,19 @@@ def get_voice_chat(request: Request) -@router.put("/voice-chat", summary="Continue voice calls in this Jarvis chat")-async def put_voice_chat(body: VoiceChatBody, request: Request) -> VoiceChatResponse:+def put_voice_chat(body: VoiceChatBody, request: Request) -> VoiceChatResponse:"""Bind the chat the front page shows: calls file into it and start with its history."""svc = _service(request)+ voice_session = None if body.session_id else (body.voice_session_id or "").strip() or None+ history = None+ if voice_session is not None:+ history = _archived_voice_history(request, voice_session)+ if history is None:+ raise HTTPException(status_code=404, detail="no-such-voice-chat")try:- svc.bind_voice_chat(body.session_id or None)+ svc.bind_voice_chat(+ body.session_id or None, voice_session=voice_session, voice_history=history+ )except NoSuchSession as exc:raise HTTPException(status_code=404, detail="no-such-jarvis-chat") from excreturn _voice_chat_answer(svc)diff --cc jarvis/ui/web/frontend/src/components/agentchat/WorkTrace.test.tsxindex 85106b508b,918f7a774c..50d6d023b0--- a/jarvis/ui/web/frontend/src/components/agentchat/WorkTrace.test.tsx+++ b/jarvis/ui/web/frontend/src/components/agentchat/WorkTrace.test.tsx@@@ -179,32 -200,6 +200,32 @@@ describe("work trace", () =>expect(splitConversationTurn([tool("a"), reply("done", "Ready."), failed]).after).toEqual([failed]);});+ it("keeps a failed tool and its outcome visible after a conversation completes", () => {+ const failed = tool("err", { isError: true, output: "Upload failed" });+ const { container } = render(<WorkTrace {...props} conversation blocks={[tool("a"), failed, reply("done", "I prepared a draft.")]} />);+ expect(screen.getByText("Upload failed")).toBeTruthy();+ expect(container.querySelector('[data-trace-tool="err"]')).toBeTruthy();+ expect(screen.getByTestId("tool-failure-warning").textContent).toContain("A tool action failed");+ expect(screen.getByRole("status").textContent).toContain("A tool action failed");+ expect(screen.getAllByRole("status").at(-1)?.textContent).toContain("Done");+ const fold = screen.getByTestId("conversation-work-fold").querySelector("button")!;+ fireEvent.click(fold);- expect(screen.getAllByText("Upload failed").length).toBeGreaterThan(0);++ expect(screen.getAllByText(/Upload failed/).length).toBeGreaterThan(0);+ });++ it("keeps a failed question poll visible after a conversation completes", () => {+ const failedPoll = tool("poll", {+ name: "society_ask_user",+ input: { wait_for: "closed-question" },+ isError: true,+ output: "The question is closed.",+ });+ const { container } = render(<WorkTrace {...props} conversation blocks={[tool("a"), failedPoll, reply("done", "I could not get an answer.")]} />);+ expect(container.querySelector('[data-trace-tool="poll"]')).toBeTruthy();+ expect(screen.getByText("The question is closed.")).toBeTruthy();+ expect(screen.getByTestId("tool-failure-warning")).toBeTruthy();+ });+it("treats a tool-only turn as work", () => {expect(splitConversationTurn([tool("a")])).toEqual({ work: [tool("a")], answer: [], after: [] });});diff --cc jarvis/ui/web/frontend/src/components/agentchat/WorkTrace.tsxindex 776677cd6f,67c5cea727..0832f6a27f--- a/jarvis/ui/web/frontend/src/components/agentchat/WorkTrace.tsx+++ b/jarvis/ui/web/frontend/src/components/agentchat/WorkTrace.tsx@@@ -630,9 -660,16 +662,13 @@@ function WorkTraceBody({ blocks: rawBloconst blocks = useMemo(() => withoutQuestionPolls(rawBlocks), [rawBlocks]);const live = status === "running";const elapsed = useClock(startedMs, live);- const split = useMemo(() => conversation && !live ? splitConversationTurn(blocks) : null, [blocks, conversation, live]);+ // The rail look folds every finished turn, conversation or not, the way+ // Claude and Codex do: "Worked for …" opens the turn's timeline+ // (TraceTimeline), the reply stands alone. The classic look folds+ // conversation turns only, as before.+ const split = useMemo(() => (conversation || rail) && !live ? splitConversationTurn(blocks) : null, [blocks, conversation, rail, live]);- // A finished conversation turn shows the reply and nothing else. All work- // — tools, thoughts, intermediate replies, failures, interruptions, and- // post-reply work — folds behind the "Thought for …" toggle. Pending- // approvals stay visible both ways: beside the toggle while it is closed- // (they need a tap) and inside the open chain.+ // Completed failures and pending approvals stay visible beside the fold.+ // Other work can collapse without hiding an action that needs attention.const fold = useMemo(() => {if (!split) return null;const workAll = [...split.work, ...split.after];@@@ -645,12 -682,13 +681,15 @@@}, [split]);const groups = useMemo(() => conversation ? groupConversationTrace(fold ? fold.workAll : blocks) : groupActivityTrace(blocks), [blocks, conversation, fold]);const restGroups = useMemo(() => fold ? groupConversationTrace(fold.answer) : null, [fold]);+ // A live turn keeps its replies and streaming pieces in place; a folded+ // one tells its narration as the timeline's prose.+ const timeline = useTimeline(rail ? (fold ? fold.workAll : blocks) : NO_BLOCKS, status, !fold);const asking = blocks.some(isOpenQuestion);const pending = asking || blocks.some(block => block.kind === "tool" && block.approval?.decision === null);- const outcome = asking ? "question" : pending ? "approval" : live ? "working" : status === "error" ? "failed" : status === "cancelled" ? "stopped" : "done";- const Icon = asking ? MessageCircleQuestion : pending ? ShieldQuestion : live ? CircleDashed : status === "error" ? CircleAlert : Check;+ const toolFailed = blocks.some(block => block.kind === "tool" && block.isError);+ const failed = status === "error";+ const outcome = asking ? "question" : pending ? "approval" : live ? "working" : failed ? "failed" : status === "cancelled" ? "stopped" : "done";+ const Icon = asking ? MessageCircleQuestion : pending ? ShieldQuestion : live ? CircleDashed : failed ? CircleAlert : Check;const groupProps = { live, status, onDecide, renderText, conversation, rail, t };// A turn-level error next to a reply folds with the work — it stays one// tap away behind the toggle. With no reply the error IS the outcome, so@@@ -666,14 -704,16 +705,17 @@@// The state line is the thread's last node while work is under way (or// whenever the trace has no reply between it and the work); a finished// conversation turn closes with a quiet line under its reply instead.- const statusOnRail = !conversation || live;+ const statusOnRail = !fold && (!conversation || live);+ const petState = companion && working ? livePetState(blocks) : null;const statusLine = <div role="status" aria-live="polite" data-trace-status={outcome}className={cn("flex min-w-0 flex-wrap items-start gap-x-3 text-xs leading-6 text-muted-foreground",- statusOnRail ? "py-1" : "pb-2 pt-1", status === "error" && "text-destructive", pending && "text-foreground")}>+ statusOnRail ? "py-1" : "pb-2 pt-1", failed && "text-destructive", pending && "text-foreground")}>- <Node live={working}><Icon className={cn(nodeIcon, working && "motion-safe:animate-spin")} /></Node>+ {petState+ ? <span aria-hidden className="trace-node trace-node-pet" data-trace-pet={petState}><PetMark size={32} state={petState} /></span>+ : <Node live={working}><Icon className={cn(nodeIcon, working && "motion-safe:animate-spin")} /></Node>}<span className="inline-flex min-w-0 flex-1 flex-wrap items-center gap-x-2"><span><Live on={working}>{outcomeLabel}</Live></span>+ {toolFailed && !live && !failed ? <span className="sr-only">{t("work_trace.tool_failed")}</span> : null}{(live || durationMs !== null) ? <span aria-live="off" className="tabular-nums">{traceDuration(live ? elapsed : durationMs ?? 0)}</span> : null}{receiptNode ? <span aria-hidden className="text-muted-foreground/50">·</span> : null}{receiptNode}@@@ -682,17 -722,26 +724,28 @@@const statusItem: RailItem = { key: "trace:status", node: statusLine, rail: statusOnRail };const errorItem = (text: string, key: string): RailItem => ({ key, rail: false,node: <p role="alert" className="py-1.5 pl-7 text-sm text-destructive [overflow-wrap:anywhere]">{text}</p> });- const main = traceGroupItems({ groups, ...groupProps });+ const renderers: TimelineRenderers = {+ renderLive: (block) => block.kind === "tool" ? <TraceTool block={block} status={status} onDecide={onDecide} />+ : block.kind === "reasoning" ? <ReasoningTrace block={block} turnLive={live} compact={conversation} />+ : replyNode(block, conversation, renderText),+ liveOnRail: (block) => block.kind === "reasoning" || (block.kind === "tool" && !block.question),+ renderDetails: (block) => <ToolDetails block={block} />,+ };+ const steps = timelineItems(timeline, renderers);const rest = restGroups ? traceGroupItems({ groups: restGroups, ...groupProps }) : [];const items: RailItem[] = fold- ? [{ key: "trace:fold", rail: false, node: <ConversationWorkFold durationMs={durationMs} blocks={fold.workAll}+ ? [{ key: "trace:fold", rail: false, node: <ConversationWorkFold durationMs={durationMs} blocks={fold.workAll} timeline={timeline}+ // A turn that ended without an answer (TurnTrace names it so) has+ // nothing to read but its work: the timeline stands open.+ initiallyOpen={!answered && Boolean(completionLabel)}- attention={<div className="trace-fold-open"><Rail items={fold.approvals.map(block => ({ key: block.callId, rail: !block.question, node: <TraceTool block={block} status={status} onDecide={onDecide} /> }))} /></div>}>+ attention={<div className="trace-fold-open"><Rail items={fold.attention.map(block => ({ key: block.callId, rail: !block.question, node: <TraceTool block={block} status={status} onDecide={onDecide} /> }))} /></div>}>- <Rail items={[...main, ...(foldedError ? [errorItem(foldedError, "trace:folded-error")] : [])]} />+ <Rail items={[...steps, ...(foldedError ? [errorItem(foldedError, "trace:folded-error")] : [])]} />+ <CopyTimeline text={() => timelineMarkdown(timeline, headerLabel(timeline, durationMs, t), t)} /></ConversationWorkFold> }, ...rest]- : main;+ : steps;if (visibleError) items.push(errorItem(visibleError, "trace:error"));+ if (toolFailed && !live && !failed) items.push({ key: "trace:tool-failed", rail: false,+ node: <p data-testid="tool-failure-warning" className="flex items-center gap-1.5 py-1 pl-7 text-xs text-destructive"><CircleAlert aria-hidden className="h-3.5 w-3.5" />{t("work_trace.tool_failed")}</p> });items.push(statusItem);return <div className={cn("min-w-0", conversation && "w-full max-w-[44rem] self-start", className)} data-testid="work-trace" data-look="rail" data-state={status} {...(conversation ? { "data-conversation": "" } : {})}><Rail items={items} />diff --cc jarvis/ui/web/frontend/src/components/agentic/WorkspaceTerminalGrid.tsxindex 2fd999f5d3,041cd40179..e02e96d98f--- a/jarvis/ui/web/frontend/src/components/agentic/WorkspaceTerminalGrid.tsx+++ b/jarvis/ui/web/frontend/src/components/agentic/WorkspaceTerminalGrid.tsx@@@ -16,8 -16,7 +16,8 @@@ import { cn } from "@/lib/utils"import { PaneResizer } from "@/components/layout/PaneResizer";import { treeLayout, treeLeaves, type LayoutNode, type PaneSeam } from "./treeLayout";import { useTreeSizes } from "./useTreeSizes";+import { PANE_COMMAND_EVENT, neighborInDirection, type PaneCommandDetail } from "./ideHotkeys";- import { DOCK_LABELS, GRID_LIMIT_HINT, MAX_GRID_COLUMNS, MAX_GRID_ROWS, MAX_WORKSPACE_PANES, dockPosition, fitsWorkspace, layoutSpan, paneStyle, previewDock, workspaceLayout } from "./workspaceDocking";+ import { DOCK_LABELS, dockPosition, layoutSpan, paneStyle, previewDock, workspaceLayout } from "./workspaceDocking";const GAP = 8;const MIN_WIDTH = 280;@@@ -84,7 -79,7 +82,7 @@@ function sameFolder(left: string | undereturn /^[a-z]:\//i.test(a) ? a.toLowerCase() === b.toLowerCase() : a === b;}- export function WorkspaceTerminalGrid({ session, onChanged, onAdd, onClose, onSelect, selected, maxPanes = MAX_WORKSPACE_PANES, fontSize, appearance, disabled = false, onMutationStart, onMutationEnd, paneStyle: look = "classic", workspaces = [], active = true }: Props) {-export function WorkspaceTerminalGrid({ session, onChanged, onAdd, onClose, onSelect, selected, fontSize, appearance, disabled = false, onMutationStart, onMutationEnd, paneStyle: look = "classic", workspaces = [] }: Props) {++export function WorkspaceTerminalGrid({ session, onChanged, onAdd, onClose, onSelect, selected, fontSize, appearance, disabled = false, onMutationStart, onMutationEnd, paneStyle: look = "classic", workspaces = [], active = true }: Props) {const theme = useThemeValue();const pushToast = useEventStore((state) => state.pushToast);// The pane an agent card in the side panel pointed at, framed in blue.diff --cc jarvis/ui/web/frontend/src/components/home/TurnSteps.test.tsxindex bf617c1fe1,9c5166db17..4468a8dc56--- a/jarvis/ui/web/frontend/src/components/home/TurnSteps.test.tsx+++ b/jarvis/ui/web/frontend/src/components/home/TurnSteps.test.tsx@@@ -13,9 -7,12 +13,10 @@@ it("keeps brief voice errors visible",const steps: ThinkingStep[] = [{ id: "s", kind: "note", status: "error", labelKey: "thinking.step_update", error: "Connection lost", startedTs: 0 }];expect(traceWorthShowing(steps, 20, false)).toBe(true);render(<TurnSteps steps={steps} durationMs={20} />);- expect(await screen.findByText("Connection lost")).toBeTruthy();- // The finished trace folds into its report; the toggle says a step failed.- const toggle = screen.getByRole("button", { name: /1 failed/ });- fireEvent.click(toggle);- expect(screen.getByText(/Connection lost/)).toBeTruthy();++ // A failed step needs attention, so it stays in view with its reason.++ expect((await screen.findAllByText(/Connection lost/)).length).toBeGreaterThan(0);});-it("does not hide live work with no events", () => {+it("does not hide live work with no events", async () => {const { rerender, container } = render(<TurnSteps steps={[]} />);expect(container.textContent).toBe("");rerender(<TurnSteps steps={[]} live />);diff --cc jarvis/ui/web/frontend/src/components/layout/Sidebar.tsxindex 7eff55fec0,dedec66466..29676bf2ae--- a/jarvis/ui/web/frontend/src/components/layout/Sidebar.tsx+++ b/jarvis/ui/web/frontend/src/components/layout/Sidebar.tsx@@@ -30,9 -29,8 +30,9 @@@ import { useIdeProjectsStore } from "@/import { SidebarSearchBar } from "@/components/layout/SidebarSearchBar";import { useQuickSwitchSettings } from "@/store/quickSwitchSettings";import { useAppInstance } from "@/hooks/useAppInstance";-import { usePublishIdentity } from "@/components/marketplace/PublishIdentity";+// The query alone, not ./PublishIdentity: the sign-in UI stays out of the entry chunk.+import { usePublishIdentity } from "@/components/marketplace/publishIdentityQuery";- import { GigiMark } from "@/components/GigiMark";+ import { PetMark } from "@/components/pets/PetMark";import { MarketplaceIcon } from "@/components/icons/sectionIcons";import { startNewTextChat } from "@/lib/newChat";import { useUserName } from "@/hooks/useUserName";diff --cc jarvis/ui/web/frontend/src/components/onboarding/setup/SetupTour.tsxindex ebfb7b9b2e,38c4191c0a..b4734f1e67--- a/jarvis/ui/web/frontend/src/components/onboarding/setup/SetupTour.tsx+++ b/jarvis/ui/web/frontend/src/components/onboarding/setup/SetupTour.tsx@@@ -459,22 -457,30 +461,34 @@@ function askInputMonitoringForCallShortfunction VoiceStep({ next, later }: { next: () => void; later: () => void }) {const t = useT();const { config } = useWakeWord();- const on = Boolean(config?.enabled && config.phrase.trim());+ const [savedHere, setSavedHere] = useState(false);+ useEffect(() => {+ const onChanged = () => setSavedHere(true);+ window.addEventListener("jarvis:wake-word-changed", onChanged);+ return () => window.removeEventListener("jarvis:wake-word-changed", onChanged);+ }, []);+ const phrase = config?.phrase.trim() ?? "";+ const on = Boolean(config?.enabled && phrase);+ const saved = on || (savedHere && Boolean(phrase));+ const chooseCallShortcut = () => {+ askInputMonitoringForCallShortcut();+ later();+ };return (<div className="space-y-3">- <Status tone={on ? "ok" : "muted"} testId="setup-voice-status">- {on ? fill(t("first_run.voice.on"), { phrase: config!.phrase }) : t("first_run.voice.off")}+ <Status tone={saved ? "ok" : "muted"} testId="setup-voice-status">+ {on+ ? fill(t("first_run.voice.on"), { phrase })+ : saved+ ? fill(t("first_run.voice.saved"), { phrase })+ : t("first_run.voice.off")}</Status>- <PrimaryAction onClick={next} disabled={!on}>+ <PrimaryAction onClick={next} disabled={!saved}>{t("first_run.continue")}</PrimaryAction>- {!on && (+ {!saved && (<div className="text-center">- <QuietAction onClick={later} testId="setup-voice-later" className="text-xs">+ <QuietAction onClick={chooseCallShortcut} testId="setup-voice-later" className="text-xs">{t("first_run.voice.later")}</QuietAction></div>diff --cc jarvis/ui/web/frontend/src/components/society/chat/AgentChatPanel.tsxindex beebdc4daa,b0fa3b4770..ad6808c495--- a/jarvis/ui/web/frontend/src/components/society/chat/AgentChatPanel.tsx+++ b/jarvis/ui/web/frontend/src/components/society/chat/AgentChatPanel.tsx@@@ -272,12 -282,8 +283,13 @@@ function SpecialistChat({ agent, rostedata-session-id={sessionId ?? ""}data-session-ready={sessionReady ? "true" : "false"}>+ <AgentConversationsBar agentId={agent.agentId} agentName={agent.name} displayName={displayName} /><Transcript key={`${sessionId ?? agent.agentId}:${view.boundaryId}`} items={view.items} agent={agent} roster={roster} onDecide={decide} />+ {sessionReady && socketState !== "open" && socketState !== "idle" ? (+ <p role="status" className="px-4 pb-1 text-xs text-muted-foreground">+ {t(socketState === "closed" ? "society.chat.reconnecting" : "society.chat.connecting")}+ </p>+ ) : null}{lastError && sessionReady ? (<p role="alert" className="px-4 pb-1 text-xs text-destructive">{lastError}@@@ -413,12 -419,8 +426,13 @@@ function JarvisChat({ agent, roster }:return (<div className="flex h-full min-h-0 flex-col bg-background" data-testid="society-chat" data-mode="chat">{header}+ <AgentConversationsBar agentId={agent.agentId} agentName={displayName(agent.agentId, agent.name)} displayName={displayName} /><Transcript key={`${activeSessionId ?? ""}:${view.boundaryId}`} items={view.items} agent={agent} roster={roster} onDecide={decide} />+ {activeSessionId && socketState !== "open" && socketState !== "idle" ? (+ <p role="status" className="px-4 pb-1 text-xs text-muted-foreground">+ {t(socketState === "closed" ? "society.chat.reconnecting" : "society.chat.connecting")}+ </p>+ ) : null}{lastError ? (<p role="alert" className="px-4 pb-1 text-xs text-destructive">{lastError}diff --cc jarvis/ui/web/frontend/src/components/society/chat/ChatActivity.test.tsxindex 7070539638,0b824b917a..52747f295a--- a/jarvis/ui/web/frontend/src/components/society/chat/ChatActivity.test.tsx+++ b/jarvis/ui/web/frontend/src/components/society/chat/ChatActivity.test.tsx@@@ -80,12 -83,15 +83,15 @@@ it("keeps a failed tool visible while f{ ...tool, callId: "error", isError: true, output: "Upload failed" },{ kind: "text", id: "reply", text: "I could not finish." },]} />);- expect(screen.queryByText("Upload failed")).toBeNull();+ expect(screen.getByText("Upload failed")).toBeTruthy();expect(screen.getByText("I could not finish.")).toBeTruthy();expect(screen.queryByText("Report contents")).toBeNull();- fireEvent.click(screen.getByRole("button", { name: "Thought for 2.0s" }));- expect(screen.getAllByText("Upload failed").length).toBeGreaterThan(0);- // The open fold expands tool details too — no second tap needed.+ fireEvent.click(screen.getByRole("button", { name: /^Worked for 2\.0s.*1 failed/ }));+ // The failure reads under its line with the tool's own reason.+ expect(screen.getByText("Failed: Upload failed")).toBeTruthy();+ // The raw output stays one tap further, under the line.+ expect(screen.queryByText("Report contents")).toBeNull();+ fireEvent.click(screen.getByRole("button", { name: /^Explored/ }));expect(screen.getByText("Report contents")).toBeTruthy();});@@@ -95,12 -101,13 +101,11 @@@ it("keeps failures and pending approvalbase,{ ...base, callId: "approval", isError: false, output: null, approval: { approvalId: "ap", summary: "Send this message?", decision: null } },]} onDecide={() => undefined} />);- expect(screen.getByText("Delivery failed")).toBeTruthy();- expect(screen.queryByText("Delivery failed")).toBeNull();- expect(screen.getByText("Send this message?")).toBeTruthy();- expect(screen.getByRole("button", { name: "Approve" })).toBeTruthy();- fireEvent.click(screen.getByRole("button", { name: /^Worked for 1\.0s/ }));+ expect(screen.getByText("Failed: Delivery failed")).toBeTruthy();- // The approval card survives opening the fold — it still needs a tap.+ expect(screen.getByText("Send this message?")).toBeTruthy();expect(screen.getByRole("button", { name: "Approve" })).toBeTruthy();+ // With no other work to fold, both items stay in place and need no toggle.+ expect(screen.queryByTestId("conversation-work-fold")).toBeNull();- expect(screen.getByRole("button", { name: "Approve" })).toBeTruthy();});it("shows agent message direction and truthful delivery state without preview clutter", () => {@@@ -119,26 -126,30 +124,30 @@@ it("folds successful work while showinconst tool: ToolBlock = { kind: "tool", callId: "a", name: "read_file", input: { path: "report.csv" }, output: "Report contents", isError: false, durationMs: 100, approval: null, startedMs: 0 };const blocks = [tool, { ...tool, callId: "b", name: "write_file" }, { kind: "text" as const, id: "reply", text: "Your report is ready." }, { ...tool, callId: "error", isError: true, output: "Upload failed" }];const { rerender } = render(<WorkTrace conversation status="running" startedMs={0} durationMs={null} blocks={blocks} />);- const activity = screen.getByRole("button", { name: "Reading files Creating files" });- expect(activity.getAttribute("aria-expanded")).toBe("true");- fireEvent.click(activity);- fireEvent.click(activity);+ // While it runs, finished calls already read as their timeline lines.+ expect(screen.getByRole("button", { name: /^Explored/ })).toBeTruthy();+ expect(screen.getByRole("button", { name: /^Created report\.csv/ })).toBeTruthy();rerender(<WorkTrace conversation status="done" startedMs={0} durationMs={1000} blocks={blocks} />);- expect(screen.queryByRole("button", { name: "Reading files Creating files" })).toBeNull();- expect(screen.queryByRole("button", { name: /Write file/ })).toBeNull();+ expect(screen.queryByRole("button", { name: /^Explored/ })).toBeNull();expect(screen.getByText("Your report is ready.")).toBeTruthy();- expect(screen.queryByText("Upload failed")).toBeNull();+ expect(screen.getByText("Upload failed")).toBeTruthy();expect(screen.queryByText("Report contents")).toBeNull();- fireEvent.click(screen.getByRole("button", { name: "Thought for 1.0s" }));- // One tap opens the whole chain: the post-reply error and the tool details.- expect(screen.getAllByText("Upload failed").length).toBeGreaterThan(0);+ const toggle = screen.getByRole("button", { name: /^Worked for 1\.0s/ });+ expect(toggle.textContent).toContain("Read 2 files and created a file");+ fireEvent.click(toggle);+ // One tap opens the whole timeline: every call in order, the post-reply+ // error included, with the reply kept where it was.+ const text = screen.getByTestId("work-trace").textContent ?? "";+ expect(text.indexOf("Readreport.csv")).toBeGreaterThanOrEqual(0);+ expect(text.indexOf("Readreport.csv")).toBeLessThan(text.indexOf("Createdreport.csv"));+ expect(text).toContain("Failed: Upload failed");+ expect(screen.getAllByText("Your report is ready.")).toHaveLength(1);+ // Each line's raw call stays tappable on its own.+ const explored = screen.getByRole("button", { name: /^Explored/ });+ fireEvent.click(explored);expect(screen.getAllByText("Report contents").length).toBeGreaterThan(0);- // Inner rows stay tappable: collapsing the group hides the details again.- fireEvent.click(screen.getByRole("button", { name: "Read files Created files" }));+ fireEvent.click(explored);expect(screen.queryAllByText("Report contents")).toHaveLength(0);- expect(screen.getAllByText("Upload failed").length).toBeGreaterThan(0);- fireEvent.click(screen.getByRole("button", { name: "Read files Created files" }));- expect(screen.getAllByText("Report contents").length).toBeGreaterThan(0);});it("does not offer a thought toggle when the turn is only a reply", () => {diff --cc jarvis/ui/web/frontend/src/i18n/locales/de.jsonindex 9f928421bf,f4b7cc4cd7..a4ba287b70--- a/jarvis/ui/web/frontend/src/i18n/locales/de.json+++ b/jarvis/ui/web/frontend/src/i18n/locales/de.json@@@ -212,9 -166,10 +212,9 @@@"group_tools": "Werkzeuge","group_you": "Du","group_system": "System",- "agent_instructions": "{name}.md",+ "agent_instructions": "{name}","appshots": "Appshots",- "shortcuts": "Tastenkürzel",- "pets": "Meine Pets",+ "jarvisx": "Jarvis X","jarvis_actions": "Jarvis-Aktionen","marketplace": "Marketplace","agentic_ide": "Agentic IDE",@@@ -222,27 -177,74 +222,76 @@@"voice": "{name} Stimme","voice_shortcuts": "Tastenkürzel","voice_language": "Sprache",- "voice_api_keys": "API-Keys"+ "voice_api_keys": "API-Keys",+ "shortcuts": "Tastenkürzel",+ "pets": "Meine Pets"},- "agent_instructions": {- "subtitle": "Deine persönlichen Präferenzen, wie der Assistent mit dir arbeitet — Ton, Sprache, Voreinstellungen, dauerhafte Fakten. Getrennt vom System-Prompt und hebelt niemals Sicherheit oder Bestätigungen aus.",- "active_badge": "Aktiv",- "empty_badge": "Leer",- "editor_label": "Deine Anweisungen (Markdown)",- "placeholder": "Schreibe deine persönlichen Präferenzen…",- "chars": "{0} Zeichen",- "empty_hint": "Leer - Speichern leert die Datei, oder lade die Vorlage.",- "save": "Anweisungen speichern",- "saving": "Speichern…",- "saved": "Anweisungen gespeichert",+ "assistant_view": {+ "header_named": "Dein Assistent in {0}, geweckt mit „{1}“.",+ "header_unnamed": "Dein Assistent in {0}. Wähle ein Aktivierungswort, um ihm einen Namen zu geben.",+ "reload": "Neu laden",+ "vibe_missing": "Für {name} ist noch kein Charakter aufgeschrieben.",+ "learning_on": "Lernt",+ "learning_off": "Lernt gerade nicht",+ "learning_on_hint": "{name} schreibt und korrigiert die eigenen Notizen, während ihr sprecht.",+ "learning_off_hint": "Die Lernschleife läuft in dieser Sitzung nicht, deshalb lassen sich Notizen gerade nicht vergessen.",+ "fact_memory_one": "{0} Sache gemerkt",+ "fact_memory_other": "{0} Sachen gemerkt",+ "fact_changed": "geändert {0}",+ "character_title": "Charakter",+ "edit": "Bearbeiten",+ "who_label": "Über",+ "tone_title": "Ton",+ "limits_title": "Grenzen",+ "character_empty": "SOUL.md beschreibt noch keinen Charakter.",+ "character_missing": "SOUL.md wurde noch nicht angelegt. Sie entsteht beim ersten Start.",+ "memory_title": "Gedächtnis",+ "tab_memory": "Gemerkt",+ "tab_user": "Über dich",+ "tab_self": "Über sich",+ "empty_memory": "Noch nichts. Sag „merk dir …“, und es landet hier.",+ "empty_user": "Noch nichts. Was {name} über dich bemerkt, erscheint hier nach Gesprächen.",+ "empty_soul": "Noch nichts. Sag {name}, wie du es haben willst, und {name} schreibt die Notiz selbst.",+ "explicit": "Von dir",+ "forget": "Vergessen",+ "forget_done": "Vergessen",+ "forget_needs_loop": "Notizen lassen sich nur vergessen, während die Lernschleife läuft.",+ "recent_title": "Zuletzt gelernt",+ "recent_empty": "Noch nichts gelernt.",+ "op_add": "Hinzugefügt: {0}",+ "op_replace": "Geändert: {0}",+ "op_remove": "Entfernt: {0}",+ "place_memory": "Gedächtnis",+ "place_user": "Notizen über dich",+ "place_soul": "Charakter",+ "said": "Du hast gesagt: „{0}“",+ "files_title": "Dateien",+ "files_hint": "{name} liest sie zu Beginn jedes Gesprächs.",+ "file_role_soul": "Charakter",+ "file_role_instructions": "Deine Anweisungen",+ "file_role_memory": "Gedächtnis",+ "file_role_user": "Über dich",+ "file_missing": "Noch nicht angelegt",+ "file_notes_one": "{0} Notiz",+ "file_notes_other": "{0} Notizen",+ "file_chars_one": "{0} Zeichen",+ "file_chars_other": "{0} Zeichen",+ "editor_label": "{0} (Markdown)",+ "soul_placeholder": "Beschreibe, wer {name} ist: Rolle, Stimmung, Ton, Grenzen …",+ "instructions_placeholder": "Schreib, wie {name} mit dir arbeiten soll …",+ "save": "Speichern",+ "saving": "Speichern …",+ "saved": "Gespeichert",+ "cleared": "Anweisungen geleert","revert": "Verwerfen",- "reset": "Leeren",- "reset_done": "Anweisungen geleert",+ "clear": "Leeren",+ "unsaved": "Ungespeicherte Änderungen","load_template": "Mit Vorlage starten",- "write_from_scratch": "Selbst schreiben",- "applies_next_turn": "Gilt ab der nächsten Antwort deines Assistenten — kein Neustart nötig."+ "soul_note": "Gilt ab der nächsten Antwort von {name}. Der Name folgt dem Aktivierungswort.",+ "instructions_note": "Gilt ab der nächsten Antwort von {name}. Hebt nie Sicherheitsregeln oder Bestätigungen auf.",+ "notebook_note": "{name} schreibt diese Datei selbst. Um eine Notiz zu ändern, sag es {name} einfach.",+ "error_title": "Diese Seite konnte nicht geladen werden",+ "retry": "Erneut versuchen"},"extensions": {"group_label": "Anpassen",diff --cc jarvis/ui/web/frontend/src/i18n/locales/en.jsonindex 54eb34ee17,4b88953179..fbd8769a3a--- a/jarvis/ui/web/frontend/src/i18n/locales/en.json+++ b/jarvis/ui/web/frontend/src/i18n/locales/en.json@@@ -212,9 -166,10 +212,9 @@@"group_tools": "Tools","group_you": "You","group_system": "System",- "agent_instructions": "{name}.md",+ "agent_instructions": "{name}","appshots": "Appshots",- "shortcuts": "Keyboard shortcuts",- "pets": "My Pets",+ "jarvisx": "Jarvis X","jarvis_actions": "Jarvis actions","marketplace": "Marketplace","agentic_ide": "Agentic IDE",@@@ -222,27 -177,74 +222,76 @@@"voice": "{name} Voice","voice_shortcuts": "Shortcuts","voice_language": "Language",- "voice_api_keys": "API Keys"+ "voice_api_keys": "API Keys",+ "shortcuts": "Keyboard shortcuts",+ "pets": "My Pets"},- "agent_instructions": {- "subtitle": "Your personal preferences for how the assistant works with you — tone, language, defaults, standing facts. Separate from the System Prompt, and it never overrides safety or confirmations.",- "active_badge": "Active",- "empty_badge": "Empty",- "editor_label": "Your instructions (Markdown)",- "placeholder": "Write your personal preferences…",- "chars": "{0} characters",- "empty_hint": "Empty - save to clear the file, or start from the template.",- "save": "Save instructions",+ "assistant_view": {+ "header_named": "Your assistant in {0}, woken by “{1}”.",+ "header_unnamed": "Your assistant in {0}. Choose a wake word to give it a name.",+ "reload": "Reload",+ "vibe_missing": "{name} has no character written down yet.",+ "learning_on": "Learning",+ "learning_off": "Not learning right now",+ "learning_on_hint": "{name} writes and corrects its notes while you talk.",+ "learning_off_hint": "The learning loop is not running in this session, so notes cannot be forgotten right now.",+ "fact_memory_one": "{0} thing remembered",+ "fact_memory_other": "{0} things remembered",+ "fact_changed": "changed {0}",+ "character_title": "Character",+ "edit": "Edit",+ "who_label": "About",+ "tone_title": "Tone",+ "limits_title": "Limits",+ "character_empty": "SOUL.md does not describe a character yet.",+ "character_missing": "SOUL.md has not been created yet. It appears after the first start.",+ "memory_title": "Memory",+ "tab_memory": "Remembered",+ "tab_user": "About you",+ "tab_self": "About itself",+ "empty_memory": "Nothing yet. Say “remember …” and it lands here.",+ "empty_user": "Nothing yet. What {name} notices about you appears here after conversations.",+ "empty_soul": "Nothing yet. Tell {name} how you want it to be, and it writes the note itself.",+ "explicit": "You asked",+ "forget": "Forget",+ "forget_done": "Forgotten",+ "forget_needs_loop": "Notes can only be forgotten while the learning loop runs.",+ "recent_title": "Recently learned",+ "recent_empty": "Nothing learned yet.",+ "op_add": "Added to {0}",+ "op_replace": "Changed in {0}",+ "op_remove": "Removed from {0}",+ "place_memory": "memory",+ "place_user": "notes about you",+ "place_soul": "character",+ "said": "You said: “{0}”",+ "files_title": "Files",+ "files_hint": "{name} reads these at the start of every conversation.",+ "file_role_soul": "Character",+ "file_role_instructions": "Your instructions",+ "file_role_memory": "Memory",+ "file_role_user": "About you",+ "file_missing": "Not created yet",+ "file_notes_one": "{0} note",+ "file_notes_other": "{0} notes",+ "file_chars_one": "{0} character",+ "file_chars_other": "{0} characters",+ "editor_label": "{0} (Markdown)",+ "soul_placeholder": "Describe who {name} is: role, vibe, tone, limits…",+ "instructions_placeholder": "Write how {name} should work with you…",+ "save": "Save","saving": "Saving…",- "saved": "Instructions saved",- "revert": "Revert changes",- "reset": "Clear",- "reset_done": "Instructions cleared",+ "saved": "Saved",+ "cleared": "Instructions cleared",+ "revert": "Revert",+ "clear": "Clear",+ "unsaved": "Unsaved changes","load_template": "Start from template",- "write_from_scratch": "Write from scratch",- "applies_next_turn": "Applies on your assistant's next message — no restart needed."+ "soul_note": "Applies from the next reply of {name}. The name follows the wake word.",+ "instructions_note": "Applies from the next reply of {name}. Never overrides safety rules or confirmations.",+ "notebook_note": "{name} writes this file itself. To change a note, just tell {name}.",+ "error_title": "This page could not be loaded",+ "retry": "Try again"},"extensions": {"group_label": "Customize",diff --cc jarvis/ui/web/frontend/src/i18n/locales/es.jsonindex bb635024a4,66f0a9b5ec..4741c7ed99--- a/jarvis/ui/web/frontend/src/i18n/locales/es.json+++ b/jarvis/ui/web/frontend/src/i18n/locales/es.json@@@ -212,9 -166,10 +212,9 @@@"group_tools": "Herramientas","group_you": "Tú","group_system": "Sistema",- "agent_instructions": "{name}.md",+ "agent_instructions": "{name}","appshots": "Appshots",- "shortcuts": "Atajos de teclado",- "pets": "Mis mascotas",+ "jarvisx": "Jarvis X","jarvis_actions": "Acciones de Jarvis","marketplace": "Marketplace","agentic_ide": "IDE agéntico",@@@ -222,27 -177,74 +222,76 @@@"voice": "Voz de {name}","voice_shortcuts": "Atajos","voice_language": "Idioma",- "voice_api_keys": "Claves API"+ "voice_api_keys": "Claves API",+ "shortcuts": "Atajos de teclado",+ "pets": "Mis mascotas"},- "agent_instructions": {- "subtitle": "Tus preferencias personales sobre cómo el asistente trabaja contigo — tono, idioma, valores por defecto, hechos permanentes. Separado del System Prompt y nunca anula la seguridad ni las confirmaciones.",- "active_badge": "Activo",- "empty_badge": "Vacío",- "editor_label": "Tus instrucciones (Markdown)",- "placeholder": "Escribe tus preferencias personales…",- "chars": "{0} caracteres",- "empty_hint": "Vacío - guarda para vaciar el archivo o carga la plantilla.",- "save": "Guardar instrucciones",+ "assistant_view": {+ "header_named": "Tu asistente en {0}, se despierta con «{1}».",+ "header_unnamed": "Tu asistente en {0}. Elige una palabra de activación para darle un nombre.",+ "reload": "Recargar",+ "vibe_missing": "{name} aún no tiene un carácter escrito.",+ "learning_on": "Aprendiendo",+ "learning_off": "No aprende ahora",+ "learning_on_hint": "{name} escribe y corrige sus notas mientras habláis.",+ "learning_off_hint": "El ciclo de aprendizaje no se está ejecutando en esta sesión, así que ahora no se pueden olvidar notas.",+ "fact_memory_one": "{0} cosa recordada",+ "fact_memory_other": "{0} cosas recordadas",+ "fact_changed": "cambiado {0}",+ "character_title": "Carácter",+ "edit": "Editar",+ "who_label": "Sobre",+ "tone_title": "Tono",+ "limits_title": "Límites",+ "character_empty": "SOUL.md aún no describe un carácter.",+ "character_missing": "SOUL.md aún no se ha creado. Aparece tras el primer inicio.",+ "memory_title": "Memoria",+ "tab_memory": "Recordado",+ "tab_user": "Sobre ti",+ "tab_self": "Sobre sí",+ "empty_memory": "Nada aún. Di «recuerda …» y aparecerá aquí.",+ "empty_user": "Nada aún. Lo que {name} note de ti aparecerá aquí tras las conversaciones.",+ "empty_soul": "Nada aún. Dile a {name} cómo quieres que sea y {name} escribirá la nota.",+ "explicit": "Lo pediste",+ "forget": "Olvidar",+ "forget_done": "Olvidado",+ "forget_needs_loop": "Las notas solo se pueden olvidar mientras el ciclo de aprendizaje está activo.",+ "recent_title": "Aprendido hace poco",+ "recent_empty": "Aún no ha aprendido nada.",+ "op_add": "Añadido a {0}",+ "op_replace": "Cambiado en {0}",+ "op_remove": "Quitado de {0}",+ "place_memory": "la memoria",+ "place_user": "las notas sobre ti",+ "place_soul": "el carácter",+ "said": "Dijiste: «{0}»",+ "files_title": "Archivos",+ "files_hint": "{name} los lee al empezar cada conversación.",+ "file_role_soul": "Carácter",+ "file_role_instructions": "Tus instrucciones",+ "file_role_memory": "Memoria",+ "file_role_user": "Sobre ti",+ "file_missing": "Aún no creado",+ "file_notes_one": "{0} nota",+ "file_notes_other": "{0} notas",+ "file_chars_one": "{0} carácter",+ "file_chars_other": "{0} caracteres",+ "editor_label": "{0} (Markdown)",+ "soul_placeholder": "Describe quién es {name}: rol, estilo, tono, límites…",+ "instructions_placeholder": "Escribe cómo debe trabajar {name} contigo…",+ "save": "Guardar","saving": "Guardando…",- "saved": "Instrucciones guardadas",- "revert": "Descartar cambios",- "reset": "Vaciar",- "reset_done": "Instrucciones vaciadas",- "load_template": "Empezar con plantilla",- "write_from_scratch": "Escribir desde cero",- "applies_next_turn": "Se aplica en el próximo mensaje de tu asistente — sin reinicio."+ "saved": "Guardado",+ "cleared": "Instrucciones borradas",+ "revert": "Descartar",+ "clear": "Borrar",+ "unsaved": "Cambios sin guardar",+ "load_template": "Empezar con la plantilla",+ "soul_note": "Se aplica desde la próxima respuesta de {name}. El nombre sigue a la palabra de activación.",+ "instructions_note": "Se aplica desde la próxima respuesta de {name}. Nunca anula las reglas de seguridad ni las confirmaciones.",+ "notebook_note": "{name} escribe este archivo por sí mismo. Para cambiar una nota, díselo a {name}.",+ "error_title": "No se pudo cargar esta página",+ "retry": "Reintentar"},"extensions": {"group_label": "Personalizar",diff --cc jarvis/ui/web/frontend/src/i18n/locales/onboarding/de.jsonindex 2427a325dd,3e59669aca..65fb1ba1ef--- a/jarvis/ui/web/frontend/src/i18n/locales/onboarding/de.json+++ b/jarvis/ui/web/frontend/src/i18n/locales/onboarding/de.json@@@ -57,10 -57,16 +57,11 @@@"why": "Ein Abo ist ein fester Monatspreis. Ohne Abo nutzen die Agents deinen API-Schlüssel, und jeder Auftrag wird einzeln abgerechnet.","later": "Ich verbinde später eins"},- "permissions": {- "title": "Zugriff auf diesem Mac erlauben",- "lede": "Das sind die Mac-Berechtigungen. Erlaube die, die du möchtest; jede Zeile aktualisiert sich selbst.",- "note": "Du kannst jederzeit in den Einstellungen zurückkommen. Der Neustart am Ende wendet sie an."- },"voice": {"title": "Wähle dein Weckwort",- "lede": "Tippe hier dein Wort nach „Hey“ ein und speichere es. Das Wort wird auch der Name deines Assistenten. Kein Weckwort? Das Anruf-Kürzel funktioniert immer.",+ "lede": "Tippe hier dein Wort nach „Hey“ ein und speichere es. Das Wort wird auch der Name deines Assistenten. Kein Weckwort? Das Anruf-Kürzel funktioniert jederzeit.","on": "„{phrase}“ ist an. Sag es jederzeit.",+ "saved": "„{phrase}“ ist gespeichert. Schalte oben „Aktivierungswort einschalten“ an, damit es immer gehört wird; bis dahin funktioniert das Anruf-Kürzel.","off": "Noch kein Weckwort. Bis dahin funktioniert das Anruf-Kürzel.","later": "Überspringen, ich nutze das Anruf-Kürzel"},diff --cc jarvis/ui/web/frontend/src/i18n/locales/onboarding/es.jsonindex deb88d8b04,748a7388a2..93696100e8--- a/jarvis/ui/web/frontend/src/i18n/locales/onboarding/es.json+++ b/jarvis/ui/web/frontend/src/i18n/locales/onboarding/es.json@@@ -57,10 -57,16 +57,11 @@@"why": "Una suscripción es un precio mensual fijo. Sin ella, los agentes usan tu clave de API y cada encargo se cobra por uso.","later": "Conectaré una más tarde"},- "permissions": {- "title": "Permitir acceso en este Mac",- "lede": "Estos son los permisos del Mac. Permite los que quieras; cada fila se actualiza sola.",- "note": "Puedes volver a ellos cuando quieras en Ajustes. El reinicio final los aplica."- },"voice": {"title": "Elige tu palabra de activación",- "lede": "Escribe aquí tu palabra después de «Hey» y guárdala. La palabra también será el nombre de tu asistente. ¿Sin palabra? El atajo de llamada funciona siempre.",+ "lede": "Escribe aquí tu palabra después de «Hey» y guárdala. La palabra también será el nombre de tu asistente. ¿Sin palabra? El atajo de llamada funciona en cualquier momento.","on": "«{phrase}» está activada. Dila cuando quieras.",+ "saved": "«{phrase}» está guardada. Enciende «Activar palabra de activación» arriba para que se escuche siempre; mientras tanto funciona el atajo de llamada.","off": "Aún no hay palabra de activación. Mientras tanto funciona el atajo de llamada.","later": "Omitir, usaré el atajo de llamada"},diff --cc jarvis/ui/web/frontend/src/views/AgenticIdeView.test.tsxindex 961d97fe18,58767ba094..9e697327fd--- a/jarvis/ui/web/frontend/src/views/AgenticIdeView.test.tsx+++ b/jarvis/ui/web/frontend/src/views/AgenticIdeView.test.tsx@@@ -203,28 -173,11 +203,28 @@@ describe("Agentic IDE project flow", (expect(api.reorderIdeTerminals).not.toHaveBeenCalled();});+ it("Ctrl+B, X, then an arrow opens Codex beside the selected pane", async () => {+ const terminals = [{ key: "t1", history_id: "id1", name: "T1", display_name: "Codex" }, { key: "t2", history_id: "id2", name: "T2", display_name: "Codex" }];+ const session = { id: "w1", project_id: "p1", folder: "/code/app", name: "App work", created_at: 0,+ focus_mode: false, project: { name: "App" }, terminals, layout: balancedLayout(["t1", "t2"]) };+ api.fetchIdeState.mockResolvedValue({ ...emptyState, active: true, active_id: "w1", session });+ api.fetchIdeProjects.mockResolvedValue({ projects: [project], active_workspace_id: "w1" });+ api.addTerminal.mockResolvedValue(session);+ render(<AgenticIdeView />);+ await screen.findByRole("button", { name: "Pane add" });+ await waitFor(() => expect(api.fetchIdeAgents).toHaveBeenCalled());+ fireEvent.keyDown(document.body, { key: "b", code: "KeyB", ctrlKey: true });+ expect(await screen.findByRole("dialog", { name: "IDE shortcuts" })).toBeTruthy();+ fireEvent.keyDown(document.body, { key: "x", code: "KeyX" });+ fireEvent.keyDown(document.body, { key: "ArrowRight", code: "ArrowRight" });+ await waitFor(() => expect(api.addTerminal).toHaveBeenCalledWith({ workspace_id: "w1", agent: "codex", anchor: "T1", direction: "right" }, { onMessage: expect.any(Function) }));+ });+- it("shows the pane count and refuses a new agent once the workspace is full", async () => {- const terminals = Array.from({ length: 16 }, (_, index) => ({ key: `t${index}`, history_id: `id${index}`, name: `T${index}`, display_name: "Codex" }));+ it("shows the pane count and never refuses a new agent, however many are open", async () => {+ const terminals = Array.from({ length: 20 }, (_, index) => ({ key: `t${index}`, history_id: `id${index}`, name: `T${index}`, display_name: "Codex" }));const session = { id: "w1", project_id: "p1", folder: "/code/app", name: "App work", created_at: 0,focus_mode: false, project: { name: "App" }, terminals, layout: balancedLayout(terminals.map((terminal) => terminal.key)) };- api.fetchIdeState.mockResolvedValue({ ...emptyState, active: true, active_id: "w1", session, max_terminals: 16 });+ api.fetchIdeState.mockResolvedValue({ ...emptyState, active: true, active_id: "w1", session });api.fetchIdeProjects.mockResolvedValue({ projects: [project], active_workspace_id: "w1" });render(<AgenticIdeView />);fireEvent.click(await screen.findByRole("button", { name: "Pane add" }));diff --cc jarvis/ui/web/frontend/src/views/AgenticIdeView.tsxindex f7ae52e16e,4781b7a0e1..4419ef8695--- a/jarvis/ui/web/frontend/src/views/AgenticIdeView.tsx+++ b/jarvis/ui/web/frontend/src/views/AgenticIdeView.tsx@@@ -9,11 -9,9 +9,11 @@@ import { WorkspaceOptionsDialog } fromimport { FONT_DEFAULT } from "@/components/agentic/paneFont";import { storePaneStyle, storedPaneStyle, type PaneStyle } from "@/components/agentic/terminalThemes";import { IdeSidePanelFrame } from "@/components/agentic/sidePanel/IdeSidePanel";- import { GRID_LIMIT_HINT, MAX_WORKSPACE_PANES, canSplitFit, fitsWorkspace, isBalancedWorkspace } from "@/components/agentic/workspaceDocking";+ import { isBalancedWorkspace } from "@/components/agentic/workspaceDocking";import { AgentMark } from "@/components/agentic/AgentMark";import { CloseAgentDialog, type CloseTarget } from "@/components/agentic/CloseAgentDialog";+import { IdeHotkeyMenu } from "@/components/agentic/IdeHotkeyMenu";+import { LEADER_PASSTHROUGH, PANE_COMMAND_EVENT, PANE_INPUT_EVENT, type IdeHotkeyAction, type PaneCommand, type PaneCommandDetail, type PaneInputDetail } from "@/components/agentic/ideHotkeys";import { GitCheckoutPicker } from "@/components/agentic/git/GitCheckoutPicker";import { GitPanelDialog } from "@/components/agentic/git/GitPanelDialog";import { KEEP_CHECKOUT, prepareGit, type GitPlan } from "@/lib/gitApi";@@@ -471,79 -446,6 +453,79 @@@ export function AgenticIdeView({ onScreconst stopWorkspace = () => {if (session) setCloseRequest({ kind: "workspace", workspaceId: session.id });};+ // Ctrl+B, then a key (see components/agentic/ideHotkeys): the IDE's+ // key menu. Pane commands go to the grid that owns the pane; the rest are+ // the same calls the buttons and the sidebar make.+ const hotkeysEnabled = onScreen && !dialogOpen && !optionsOpen && !gitOpen && !closeRequest;+ const hotkeyAgents = installed.map((agent) => ({ name: agent.name, label: agent.display_name }));+ const sendPaneCommand = (command: PaneCommand) => {+ if (!session || !selected) return;+ const detail: PaneCommandDetail = { workspaceId: session.id, pane: selected, command };+ window.dispatchEvent(new CustomEvent(PANE_COMMAND_EVENT, { detail }));+ };+ const openWorkspaces = state?.workspaces ?? [];+ const goToWorkspace = (index: number) => {+ const target = openWorkspaces[index];+ if (!target) { pushToast("info", `There is no workspace ${index + 1}.`); return; }+ if (target.id !== session?.id) void activateFromTree(target.id);+ };+ const runHotkey = (hotkey: IdeHotkeyAction): void => {+ switch (hotkey.kind) {+ case "split": {+ // tmux/herdr split: the new pane runs what the focused pane runs.+ const focused = session?.terminals.find((terminal) => terminal.name === selected);+ const agent = focused?.agent ?? installed[0]?.name;+ if (!agent) { openAgentPicker(); return; }+ runHotkey({ kind: "spawn", agent, direction: hotkey.direction });+ return;+ }+ case "spawn": {+ if (!session) { setProjectDialog(true); return; }- if (session.terminals.length >= maxPanes) { pushToast("error", `This workspace is full (${maxPanes} agents). Close a pane, or open another workspace.`); return; }++ // A workspace has no pane limit and no grid bound, so a split beside++ // the focused pane always fits.+ const anchor = session.terminals.find((terminal) => terminal.name === selected);- const fits = Boolean(anchor && hotkey.direction && canSplitFit(session.layout, session.terminals, anchor.key, hotkey.direction, maxPanes));- if (anchor && hotkey.direction && !fits) pushToast("info", `No room beside ${anchor.name} there; the new agent joins the even grid.`);++ const fits = Boolean(anchor && hotkey.direction);+ addAgent(hotkey.agent, session.id, fits ? anchor!.name : undefined, fits ? hotkey.direction! : "down",+ anchor ? anchor.computer_id || null : workspaceRunsOn(session.terminals));+ return;+ }+ case "agent-picker": openAgentPicker(); return;+ case "focus-pane": sendPaneCommand({ kind: "focus", direction: hotkey.direction }); return;+ case "swap-pane": sendPaneCommand({ kind: "swap", direction: hotkey.direction }); return;+ case "maximize-pane": sendPaneCommand({ kind: "maximize" }); return;+ case "fork-pane": sendPaneCommand({ kind: "fork" }); return;+ case "rename-pane": return; // the menu asks for the name itself+ case "close-pane": {+ const terminal = session?.terminals.find((entry) => entry.name === selected);+ if (terminal) closeAgent(terminal);+ return;+ }+ case "balance": balanceLayout(); return;+ case "toggle-voice": setVoiceOpen((current) => { const next = !current; storeVoiceBubbleOpen(next); return next; }); return;+ case "workspace-index": goToWorkspace(hotkey.index); return;+ case "workspace-step": {+ if (openWorkspaces.length < 2) return;+ const at = Math.max(0, openWorkspaces.findIndex((workspace) => workspace.id === session?.id));+ goToWorkspace((at + hotkey.step + openWorkspaces.length) % openWorkspaces.length);+ return;+ }+ case "new-workspace": {+ const project = projects.find((entry) => entry.id === session?.project_id);+ if (!project) { setProjectDialog(true); return; }+ setWorkspaceProject(project); setWorkspaceName(""); setWorkspaceAgents([installed[0]?.name ?? ""]);+ setWorkspaceGit(KEEP_CHECKOUT); setWorkspaceComputer(storedRunOn(project.id));+ return;+ }+ case "new-worktree-workspace": newWorktreeWorkspace(); return;+ case "rename-workspace":+ if (session) { setRenameValue(session.name ?? session.project.name); setRenameOpen(true); }+ return;+ case "close-workspace": stopWorkspace(); return;+ case "git-panel": if (session) setGitOpen(true); return;+ case "workspace-options": if (session) setOptionsOpen(true); return;+ case "connect-project": setProjectDialog(true); return;+ }+ };const closeTarget: CloseTarget | null = !closeRequest ? null: closeRequest.kind === "terminal"? { kind: "terminal", name: closeRequest.terminal.name, agent: closeRequest.terminal.agent, displayName: closeRequest.terminal.display_name }@@@ -554,7 -456,7 +536,7 @@@return <div className="relative flex h-full min-h-0 flex-col bg-background text-foreground" data-testid="igentic-ide"><WorkspaceOptionsDialog open={optionsOpen && !!session} onOpenChange={setOptionsOpen} workspace={session?.name ?? session?.project.name ?? ""}- count={session?.terminals.length ?? 0} maxPanes={maxPanes} busy={busy} canAdd={agents.some((agent) => agent.installed && (agent.kind === "shell" || agent.accepts_prompts !== false))}- count={session?.terminals.length ?? 0} busy={busy} canAdd={installed.length > 0}++ count={session?.terminals.length ?? 0} busy={busy} canAdd={agents.some((agent) => agent.installed && (agent.kind === "shell" || agent.accepts_prompts !== false))}onAdd={openAgentPicker} onBalance={balanceLayout} onRename={() => { setRenameValue(session?.name ?? session?.project.name ?? ""); setRenameOpen(true); }}onClose={stopWorkspace} onGit={() => setGitOpen(true)} appearance={appearance} onAppearance={saveAppearance}paneStyle={paneStyle} onPaneStyle={savePaneStyle}@@@ -564,9 -466,9 +546,9 @@@<CloseAgentDialog target={closeTarget} busy={busy} onCancel={() => setCloseRequest(null)} onConfirm={confirmClose} /><main className="min-h-0 flex-1">- <IdeSidePanelFrame markInUse={paneStyle === "minimal"}>- {session ? <WorkspaceTerminalGrid key={session.id} session={session} onChanged={(next) => setState((current) => current?.session?.id === next.id ? { ...current, session: next } : current)}+ <IdeSidePanelFrame markInUse={paneStyle === "minimal"} appearance={appearance ?? undefined} onScreen={onScreen}>+ {session ? <RetainedWorkspaceGrid session={session} onScreen={onScreen} workspaceIds={state.workspaces?.map((workspace) => workspace.id)} onChanged={(next) => setState((current) => current?.session?.id === next.id ? { ...current, session: next } : current)}- onAdd={openAgentPicker} onClose={closeAgent} onSelect={setSelected} selected={selected} maxPanes={maxPanes} fontSize={fontSize} appearance={appearance} disabled={busy}+ onAdd={openAgentPicker} onClose={closeAgent} onSelect={setSelected} selected={selected} fontSize={fontSize} appearance={appearance} disabled={busy}onMutationStart={beginGridMutation} onMutationEnd={endGridMutation} paneStyle={paneStyle} workspaces={state.workspaces ?? []} />: <div className="flex h-full flex-col items-center justify-center gap-3 px-6 text-center"><FolderPlus className="h-8 w-8 text-muted-foreground/70" />diff --cc jarvis/ui/web/mcp_server_routes.pyindex e9c771ded8,1fc42309f3..00a05943f2--- a/jarvis/ui/web/mcp_server_routes.py+++ b/jarvis/ui/web/mcp_server_routes.py@@@ -138,7 -138,7 +138,8 @@@ def session_ref(scope: dict[str, Any])# Society chats use a namespaced roster slug, while ordinary chats# use opaque alphanumeric IDs. Preserve that scope for tool lookup.if len(value) <= 128 and re.fullmatch(- r"society:[a-z0-9]+(?:-[a-z0-9]+)*(?::routine:[a-zA-Z0-9_-]+:[a-zA-Z0-9_-]+)?",- r"society:[a-z0-9]+(?:-[a-z0-9]+)*(?::with:[a-z0-9]+(?:-[a-z0-9]+)*)?",++ r"society:[a-z0-9]+(?:-[a-z0-9]+)*"++ r"(?::routine:[a-zA-Z0-9_-]+:[a-zA-Z0-9_-]+|:with:[a-z0-9]+(?:-[a-z0-9]+)*)?",value,):return valuediff --cc jarvis/ui/web/society_routes.pyindex 6df8a1561c,6b7bbfd89c..570b943521--- a/jarvis/ui/web/society_routes.py+++ b/jarvis/ui/web/society_routes.py@@@ -786,9 -750,20 +834,19 @@@ async def switch_agent_model(agent_id:"effort": body.effort.strip(),"account_id": body.account_id.strip(),}- if chat is not None and hasattr(chat, "controls") and chat.store.get_session(agent.session_id):- await chat.controls.pause(agent.session_id, "Model settings changed")- await chat.controls._clear_saved_native(agent.session_id)- chat = rt._get_chat()+ if chat is not None and hasattr(chat, "controls"):+ from jarvis.society.roster import PAIR_SESSION_MARKER++ # The person's chat and every conversation chat run on the card's seat.+ matching = getattr(chat.store, "list_sessions_matching", None)+ owned = [agent.session_id] + [+ s.session_id+ for s in (matching(agent.session_id + PAIR_SESSION_MARKER) if matching else [])+ ]+ for sid in owned:+ if chat.store.get_session(sid):+ await chat.controls.pause(sid, "Model settings changed")+ await chat.controls._clear_saved_native(sid)try:updated = await rt.roster.update(agent.agent_id, fields)except RosterError as exc:diff --cc tests/unit/agentic_ide/test_quick_agent_catalog.pyindex 2d2cba0bc4,9dd520f369..b0cb5612a2--- a/tests/unit/agentic_ide/test_quick_agent_catalog.py+++ b/tests/unit/agentic_ide/test_quick_agent_catalog.py@@@ -49,15 -46,11 +49,15 @@@ async def test_quick_catalog_resolves_omonkeypatch.setattr(routes, "agent_argv", resolve_agent)result = await routes.get_agents(quick=True)- assert resolved == ["example", "missing"]+ assert resolved == ["example", "missing", "shell"]assert result.terminal_available is pty_available- assert result.max_terminals == routes.MAX_TERMINALS- assert len(result.suggested_names) == routes.MAX_TERMINALS+ assert result.max_panes_per_request == routes.MAX_PANES_PER_REQUEST+ assert len(result.suggested_names) == routes.MAX_PANES_PER_REQUEST- example, missing = result.agents+ example, missing, shell = result.agents+ assert shell.installed is True+ assert shell.kind == "shell"+ assert shell.accepts_prompts is False+ assert shell.display_name == "Plain Terminal"assert example.installed is Trueassert missing.installed is Falseassert example.version is None