Skip to content

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.

merge: land the maintainer's local main on GitHub main

rubenluetke10-beeped4261028801
diff --cc docs/BUGS.md
index c23598e182,47620d655f..4f11de4664
--- a/docs/BUGS.md
+++ b/docs/BUGS.md
@@@ -15561,364 -15514,99 +15561,461 @@@ safe in destructors); `__del__` only en
started 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.md
index 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.
## Code
diff --cc docs/os-parity.md
index 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__.py
index 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_tls
diff --cc jarvis/agentic_ide/orchestration.py
index 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 terminal
count = 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 terminal
count = 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.py
index 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.py
index 30f5a44b4d,03511e2c75..58a51351b1
--- a/jarvis/appshot/hotkey.py
+++ b/jarvis/appshot/hotkey.py
@@@ -30,28 -61,25 +61,41 @@@ class ShortcutStatus
return {"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: PLC0415
from jarvis.trigger.hotkey import validate_hotkey # noqa: PLC0415
diff --cc jarvis/brain/workspace_tool.py
index 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 False
and status not in {"uncertain", "unavailable", "stale_target", "not_accepted"},
diff --cc jarvis/live/config.py
index 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_RULE
from 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 session
if 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.py
index 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 loggin
from collections.abc import Callable
from typing import Any, Final
+ from jarvis.core.agent_brief import AGENT_BRIEF_RULE
+from jarvis.core.delegation import origin_metadata
from jarvis.core.protocols import ExecutionContext, ToolResult
+ from jarvis.society.agent_names import AgentLookup, coding_pane_hint, lookup_agent
from jarvis.society.communication import REPLY_POLICY_SCHEMA, select_reply_policy
log = 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.py
index 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)
+ ):
+ continue
prespawn = getattr(provider_cls, "prespawn_transport", None)
if callable(prespawn):
await prespawn(cfg)
diff --cc jarvis/society/agent_tools.py
index 5ac693c98e,a1c9db05d3..8fe3a6f2a5
--- a/jarvis/society/agent_tools.py
+++ b/jarvis/society/agent_tools.py
@@@ -219,10 -237,13 +237,17 @@@ class MessageAgentTool
FailureReason.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_id
env = await rt.say(
from_agent=caller.agent_id,
to_agent=target.agent_id,
diff --cc jarvis/society/chat_binding.py
index 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: AgentRe
return 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_runner
provider, 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_id
if 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"] = workspace
if 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.py
index 4d8ee1ad39,d5219cb38e..0fd4c84fbe
--- a/jarvis/society/conversation.py
+++ b/jarvis/society/conversation.py
@@@ -136,24 -110,28 +143,29 @@@ class ConversationArchive
if 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.py
index 9a696ece0d,5c77aff1e0..b174f3e13e
--- a/jarvis/society/conversation_tool.py
+++ b/jarvis/society/conversation_tool.py
@@@ -36,14 -37,14 +38,17 @@@ class ConversationRecallTool
service = self._runtime.chat_service()
archive = self._runtime.conversations
if 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.py
index 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 exc
return _voice_chat_answer(svc)
diff --cc jarvis/ui/web/frontend/src/components/agentchat/WorkTrace.test.tsx
index 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.tsx
index 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: rawBlo
const 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.tsx
index 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 | unde
return /^[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.tsx
index 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.tsx
index 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.tsx
index 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 askInputMonitoringForCallShort
function 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.tsx
index 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, roste
data-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.tsx
index 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 approval
base,
{ ...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 showin
const 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.tsx
index 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.tsx
index 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 } from
import { 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({ onScre
const 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.py
index 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 value
diff --cc jarvis/ui/web/society_routes.py
index 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.py
index 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_o
monkeypatch.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 True
assert missing.installed is False
assert example.version is None