OpenJarvis 1.0.3.dev717__tar.gz → 1.0.3.dev719__tar.gz

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenJarvis
-Version: 1.0.3.dev717
+Version: 1.0.3.dev719
 Summary: OpenJarvis — modular AI assistant backend with composable intelligence primitives
 Project-URL: Homepage, https://github.com/open-jarvis/OpenJarvis
 Project-URL: Documentation, https://open-jarvis.github.io/OpenJarvis/

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "OpenJarvis"
-version = "1.0.3.dev717"
+version = "1.0.3.dev719"
 description = "OpenJarvis — modular AI assistant backend with composable intelligence primitives"
 readme = "README.md"
 requires-python = ">=3.10"

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/src/openjarvis/agents/executor.py

@@ -23,6 +23,15 @@ logger = logging.getLogger(__name__)
 
 _MAX_RETRIES = 3
 
+# Default model for monitor_operative / long-horizon agent ticks. qwen3:8b
+# emits tool_calls but, when given the full MonitorOperative system prompt
+# alongside a `think` no-op tool, reliably picks `think` instead of the real
+# action tools — producing tickless prose from training-data memory.
+# gemma4:31b follows the function-calling protocol with the same prompt and
+# actually invokes web_search / memory_retrieve. Explicit ``config["model"]``
+# on an agent still wins.
+_AGENT_TICK_DEFAULT_MODEL = "gemma4:31b"
+
 
 class AgentExecutor:
     """Executes a single tick for a managed agent.
@@ -257,7 +266,11 @@ class AgentExecutor:
         engine = self._system.engine if self._system else None
         if engine is None:
             raise FatalError("No engine available in JarvisSystem")
-        model = config.get("model") or (self._system.model if self._system else "")
+        model = (
+            config.get("model")
+            or _AGENT_TICK_DEFAULT_MODEL
+            or (self._system.model if self._system else "")
+        )
         if not model:
             raise FatalError("No model configured for agent")
 
@@ -350,29 +363,109 @@ class AgentExecutor:
             agent_kwargs["system_prompt"] = sys_prompt
         if getattr(agent_cls, "accepts_tools", False) and tool_instances:
             agent_kwargs["tools"] = tool_instances
+        # Hand the agent our EventBus so its ToolExecutor can publish
+        # TOOL_CALL_START/END — without this, ToolExecutor's ``self._bus``
+        # is None and every tool call executes silently, which is why
+        # traces previously reported "0 steps" even when the model was
+        # actively invoking web_search/memory_*/etc.
+        if self._bus is not None:
+            agent_kwargs["bus"] = self._bus
         # Propagate confirmation policy from the AgentExecutor down to the
         # agent's own ToolExecutor. Set by CLI paths like `jarvis agents ask`
         # so non-interactive runs can auto-approve tool execution.
         if getattr(self, "_confirm_callback", None) is not None:
             agent_kwargs["interactive"] = True
             agent_kwargs["confirm_callback"] = self._confirm_callback
+
+        # Wire cross-tick state plumbing into agent classes that accept it.
+        # Without this, MonitorOperative/Operative agents have no working
+        # session_store or memory_backend and silently no-op their state
+        # recall / persistence paths.
+        import inspect
+
+        init_sig = inspect.signature(agent_cls.__init__)
+        accepts_var_kw = any(
+            p.kind == inspect.Parameter.VAR_KEYWORD
+            for p in init_sig.parameters.values()
+        )
+
+        def _accepts(name: str) -> bool:
+            return accepts_var_kw or name in init_sig.parameters
+
+        state_kwargs: dict[str, Any] = {}
+        if _accepts("operator_id"):
+            state_kwargs["operator_id"] = agent["id"]
+        if self._system is not None:
+            if _accepts("session_store"):
+                state_kwargs["session_store"] = getattr(
+                    self._system, "session_store", None
+                )
+            if _accepts("memory_backend"):
+                state_kwargs["memory_backend"] = getattr(
+                    self._system, "memory_backend", None
+                )
+
         try:
-            agent_instance = agent_cls(engine, model, **agent_kwargs)
+            agent_instance = agent_cls(
+                engine, model, **agent_kwargs, **state_kwargs
+            )
         except TypeError:
-            agent_instance = agent_cls(engine, model)
+            try:
+                agent_instance = agent_cls(engine, model, **agent_kwargs)
+            except TypeError:
+                agent_instance = agent_cls(engine, model)
+
+        # Inject the managed-agent UUID into the agent's ToolExecutor so
+        # emitted TOOL_CALL_START/END events carry it; the trace subscriber
+        # below filters by ``event.data["agent"] == agent_id`` and would
+        # otherwise drop every tool call (the class-level agent_id like
+        # "monitor_operative" doesn't match the runtime UUID).
+        inner_executor = getattr(agent_instance, "_executor", None)
+        if inner_executor is not None and hasattr(inner_executor, "_agent_id"):
+            inner_executor._agent_id = agent["id"]
 
-        # Build input from instruction + summary_memory + pending messages
+        logger.info(
+            "Agent %s: tool wiring — %d tools resolved (%s), agent class %s",
+            agent["name"],
+            len(tool_instances),
+            ", ".join(t.spec.name for t in tool_instances) or "none",
+            agent_cls.__name__,
+        )
+
+        # Build input from instruction + summary_memory + pending messages.
+        # NB: we deliberately do NOT inject the full previous response back
+        # in as "Previous context" — that caused the model to parrot its
+        # own prior output verbatim. Cross-tick continuity now lives in the
+        # agent's session_store / memory_backend; here we only surface a
+        # short tick-boundary marker so the model knows time has passed.
         import datetime
+        import re
 
         today = datetime.date.today().strftime("%A, %B %d, %Y")
         instruction = config.get("instruction", "")
-        memory = agent.get("summary_memory", "")
+        memory = (agent.get("summary_memory") or "").strip()
+        last_run_at = agent.get("last_run_at")
+
+        tick_note = ""
+        if memory:
+            first_sentence = re.split(r"(?<=[.!?])\s+", memory, maxsplit=1)[0]
+            first_sentence = first_sentence.strip()[:200]
+            if last_run_at:
+                ts = datetime.datetime.fromtimestamp(last_run_at).strftime(
+                    "%Y-%m-%d %H:%M"
+                )
+                tick_note = f"Last tick at {ts}: {first_sentence}"
+            else:
+                tick_note = f"Previous tick: {first_sentence}"
+
         if instruction:
-            input_text = f"Current date: {today}\n\nStanding instruction: {instruction}"
-            if memory:
-                input_text += f"\n\nPrevious context: {memory}"
+            input_text = (
+                f"Current date: {today}\n\nStanding instruction: {instruction}"
+            )
+            if tick_note:
+                input_text += f"\n\n{tick_note}"
         else:
-            base = memory or "Continue your assigned task."
+            base = tick_note or "Continue your assigned task."
             input_text = f"Current date: {today}\n\n{base}"
         pending = self._manager.get_pending_messages(agent["id"])
         if pending:

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/src/openjarvis/agents/monitor_operative.py

@@ -49,18 +49,18 @@ MONITOR_OPERATIVE_SYSTEM_PROMPT = """\
 You are a Monitor Operative Agent designed for long-horizon tasks.
 
 ## Capabilities
-1. TOOLS: Call any available tool via function calling
-2. STATE: Your previous findings and state are automatically restored
-3. MEMORY: Store important findings for future recall
-
-## How to use tools
-
-To call a tool, write on its own lines:
-
-Action: <tool_name>
-Action Input: <json_arguments>
-
-You will receive the result, then continue your response.
+1. TOOLS: You have access to tools via native function calling. The list
+   below shows what is available — invoke them through the function-calling
+   API, not by writing tool names into your text response.
+2. STATE: Your previous findings and state are automatically restored from memory.
+3. MEMORY: Store important findings via memory_store; recall via memory_retrieve.
+
+## Critical Operating Rule
+Your training data is frozen and out of date. For ANY question about recent,
+current, or evolving information, you MUST call a substantive retrieval tool
+(web_search, memory_retrieve, or an equivalent) BEFORE composing a response.
+Writing fact claims about recent events from memory alone produces
+hallucinations and is a failure mode.
 
 ## Strategy
 - Memory extraction: {memory_extraction}
@@ -70,6 +70,9 @@ You will receive the result, then continue your response.
 
 ## Protocol
 - Break complex tasks into phases and track progress
+- Prefer substantive tools (web_search, memory_retrieve) over reasoning-only
+  tools (think) — `think` does not gather new information, only reorganises
+  what you already have
 - Store causal relationships and key findings in memory
 - Compress long tool outputs before adding to context
 - Self-evaluate retrieved context for relevance

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/src/openjarvis/connectors/gmail.py

@@ -497,6 +497,11 @@ class GmailConnector(BaseConnector):
                     timestamp=timestamp,
                     thread_id=thread_id,
                     channel=channel,
+                    # Deep-link straight to the message. ``msg_id`` is Gmail's
+                    # internal hex id, which the ``#all/<id>`` permalink
+                    # resolves directly — so citations have a working URL
+                    # without relying on _hit_url reconstruction at query time.
+                    url=f"https://mail.google.com/mail/u/0/#all/{msg_id}",
                     metadata={
                         "message_id": msg_id,
                         "rfc_message_id": rfc_message_id,

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/src/openjarvis/connectors/granola.py

@@ -76,6 +76,41 @@ def _granola_api_list_notes(
     return resp.json()
 
 
+class GranolaKeyError(ValueError):
+    """Raised when a Granola API key is missing or rejected by the API.
+
+    Surfaced through the ``/connect`` endpoint as an HTTP 400 so the user
+    sees why the key was refused instead of a silent failed sync later.
+    """
+
+
+def _granola_api_validate_key(api_key: str) -> None:
+    """Verify an API key with a minimal ``GET /v1/notes?limit=1`` probe.
+
+    Raises :class:`GranolaKeyError` when the key is empty or the API
+    responds 401/403, so an invalid key never overwrites a working
+    credential on disk. Other HTTP errors propagate via ``raise_for_status``.
+    """
+    if not api_key:
+        raise GranolaKeyError("Granola API key is empty.")
+    try:
+        resp = httpx.get(
+            f"{_GRANOLA_API_BASE}/v1/notes",
+            headers={"Authorization": f"Bearer {api_key}"},
+            params={"limit": 1},
+            timeout=30.0,
+        )
+    except httpx.HTTPError as exc:
+        raise GranolaKeyError(
+            f"Could not reach Granola to verify the key: {exc}"
+        ) from exc
+    if resp.status_code in (401, 403):
+        raise GranolaKeyError(
+            "Invalid API key. Check your key in Granola Settings → API."
+        )
+    resp.raise_for_status()
+
+
 def _granola_api_get_note(api_key: str, note_id: str) -> Dict[str, Any]:
     """Fetch a single Granola note by ID (includes transcript).
 
@@ -242,10 +277,15 @@ class GranolaConnector(BaseConnector):
         )
 
     def handle_callback(self, code: str) -> None:
-        """Persist the API key to the credentials file.
+        """Validate and persist the API key.
 
-        The *code* parameter holds the raw API key string provided by the user.
+        The *code* parameter holds the raw API key string provided by the
+        user. The key is verified with a live ``GET /v1/notes?limit=1``
+        probe *before* it is written, so an invalid key can never overwrite
+        a working credential on disk (raises :class:`GranolaKeyError` on a
+        401/403).
         """
+        _granola_api_validate_key(code)
         save_tokens(self._credentials_path, {"token": code})
 
     def sync(

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/src/openjarvis/connectors/slack_connector.py

@@ -205,17 +205,13 @@ def _validate_user_token(token: str) -> None:
         raise SlackTokenError("Slack token is empty.")
     if token.startswith(_BOT_TOKEN_PREFIX):
         raise SlackTokenError(
-            "Slack bot tokens (xoxb-) can't see user-to-user DMs. "
-            "Use a User OAuth Token (xoxp-) from "
-            "api.slack.com/apps → OAuth & Permissions, "
-            "with User Token Scopes channels:history, channels:read, "
-            "groups:history, groups:read, im:history, im:read, "
-            "mpim:history, mpim:read, users:read."
+            "Bot tokens (xoxb-) can't read DMs. "
+            "Use a User OAuth Token (xoxp-) instead."
         )
     if not token.startswith(_USER_TOKEN_PREFIX):
         raise SlackTokenError(
-            "Slack token must be a User OAuth Token (starts with 'xoxp-'). "
-            "Got a token with an unexpected prefix."
+            "Invalid token format. Expected a Slack User OAuth Token "
+            "starting with xoxp-"
         )
 
 
@@ -337,14 +333,35 @@ class SlackConnector(BaseConnector):
         return f"{_SLACK_AUTH_ENDPOINT}?{urlencode(params)}"
 
     def handle_callback(self, code: str) -> None:
-        """Persist the supplied User OAuth Token after validating its shape.
+        """Validate and persist a supplied User OAuth Token.
 
         The connector ``/connect`` endpoint funnels manually-pasted tokens
         through this method (the parameter is named ``code`` for OAuth-flow
-        compatibility). Bot tokens (``xoxb-``) are rejected here so the
-        invalid credential never lands on disk.
+        compatibility). The token is checked two ways before it is allowed
+        to touch disk, so an invalid credential never overwrites a working
+        one:
+
+        1. **Shape** — must start with ``xoxp-`` (``xoxb-`` bot tokens and
+           any other prefix are rejected via :func:`_validate_user_token`).
+        2. **Liveness** — a live ``auth.test`` call must return ``ok`` so an
+           expired or revoked token is caught at connect time.
         """
         _validate_user_token(code)
+
+        # Verify the token actually works against Slack before persisting.
+        try:
+            auth_resp = _slack_api_auth_test(code)
+        except Exception as exc:  # noqa: BLE001 — surface as a token error
+            raise SlackTokenError(
+                f"Could not verify the Slack token (auth.test failed: {exc})."
+            ) from exc
+        if not auth_resp.get("ok", False):
+            err = str(auth_resp.get("error", "auth_failed"))
+            raise SlackTokenError(
+                f"Slack rejected the token (auth.test: {err}). "
+                "Check that it is a current User OAuth Token."
+            )
+
         save_tokens(self._credentials_path, {"token": code})
         self._last_error = None
 

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/src/openjarvis/server/connectors_router.py

@@ -320,9 +320,20 @@ def create_connectors_router():
                 if req.code:
                     instance.handle_callback(req.code)
                 elif req.token:
-                    # Some OAuth connectors accept a pre-existing token.
+                    # A credential pasted into the ``token`` field. Connectors
+                    # that accept a pre-existing access token expose ``_token``
+                    # and set it directly (their real OAuth code-exchange runs
+                    # via /oauth/start → /oauth/callback). Connectors that
+                    # persist a manually-supplied credential — the Slack user
+                    # token and the Granola API key — validate inside
+                    # handle_callback, so route through it to guarantee the
+                    # credential is verified before anything touches disk. A
+                    # failed validation raises and is turned into HTTP 400
+                    # below, leaving any existing credential intact.
                     if hasattr(instance, "_token"):
                         instance._token = req.token
+                    else:
+                        instance.handle_callback(req.token)
 
             else:
                 # Generic: try to store token or credentials if the instance

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/src/openjarvis/tools/_stubs.py

@@ -225,11 +225,18 @@ class ToolExecutor:
                     success=False,
                 )
 
-        # Emit start event
+        # Emit start event. ``agent`` carries the managed-agent UUID so the
+        # AgentExecutor's trace subscriber (which filters by agent_id) can
+        # actually match this event — without it, every tool call is silently
+        # dropped from traces.
         if self._bus:
             self._bus.publish(
                 EventType.TOOL_CALL_START,
-                {"tool": tool_call.name, "arguments": params},
+                {
+                    "tool": tool_call.name,
+                    "arguments": params,
+                    "agent": self._agent_id,
+                },
             )
 
         # Execute with timeout
@@ -289,6 +296,7 @@ class ToolExecutor:
                     "latency": latency,
                     "result": result_text,
                     "metadata": event_metadata,
+                    "agent": self._agent_id,
                 },
             )
 

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/tests/connectors/test_gmail.py

@@ -150,6 +150,9 @@ def test_sync_yields_documents(
     assert doc1.content == "Hello world"
     assert doc1.thread_id == "thread1"
     assert "alice@example.com" in doc1.participants
+    # Deep-link permalink to the message must be populated at ingest time
+    # (GH #408) — not left empty for _hit_url to reconstruct later.
+    assert doc1.url == "https://mail.google.com/mail/u/0/#all/msg1"
 
     # --- Message 2 ---
     doc2 = next(d for d in docs if d.doc_id == "gmail:msg2")
@@ -157,6 +160,7 @@ def test_sync_yields_documents(
     assert doc2.author == "bob@example.com"
     assert doc2.content == "Budget reply"
     assert doc2.thread_id == "thread2"
+    assert doc2.url == "https://mail.google.com/mail/u/0/#all/msg2"
 
     # Verify the API was called correctly
     mock_list.assert_called_once()

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/tests/connectors/test_granola.py

@@ -375,3 +375,88 @@ def test_end_to_end_ingest_and_search(
     # And the client-facing sources list does end up with the stored URL.
     client_sources = build_sources_for_client([target])
     assert client_sources[0]["url"] == _NOTE_1_WEB_URL
+
+
+# ---------------------------------------------------------------------------
+# Test — API-key validation happens BEFORE the key is written to disk, so an
+# invalid key is rejected at connect time and can never overwrite a working
+# credential (the data-loss bug this guards against, GH #409).
+# ---------------------------------------------------------------------------
+
+
+class _FakeResponse:
+    """Minimal httpx.Response stand-in for the validation probe."""
+
+    def __init__(self, status_code: int) -> None:
+        self.status_code = status_code
+
+    def raise_for_status(self) -> None:
+        if self.status_code >= 400:
+            import httpx  # noqa: PLC0415
+
+            raise httpx.HTTPStatusError(
+                "error", request=None, response=None  # type: ignore[arg-type]
+            )
+
+
+def test_validate_key_empty_raises() -> None:
+    """An empty key is rejected without any network call."""
+    from openjarvis.connectors.granola import (  # noqa: PLC0415
+        GranolaKeyError,
+        _granola_api_validate_key,
+    )
+
+    with pytest.raises(GranolaKeyError):
+        _granola_api_validate_key("")
+
+
+@pytest.mark.parametrize("status", [401, 403])
+def test_validate_key_rejects_unauthorized(status: int) -> None:
+    """A 401/403 from GET /v1/notes raises GranolaKeyError with guidance."""
+    from openjarvis.connectors.granola import (  # noqa: PLC0415
+        GranolaKeyError,
+        _granola_api_validate_key,
+    )
+
+    with patch(
+        "openjarvis.connectors.granola.httpx.get",
+        return_value=_FakeResponse(status),
+    ) as mock_get:
+        with pytest.raises(GranolaKeyError) as excinfo:
+            _granola_api_validate_key("grl_bad_key")
+
+    assert str(excinfo.value) == (
+        "Invalid API key. Check your key in Granola Settings → API."
+    )
+    # The probe must hit GET /v1/notes with limit=1 (cheap validation call).
+    _, kwargs = mock_get.call_args
+    assert kwargs["params"] == {"limit": 1}
+
+
+@patch("openjarvis.connectors.granola._granola_api_validate_key")
+def test_handle_callback_persists_after_validation(mock_validate, connector) -> None:
+    """A valid key is written only after the validation probe succeeds."""
+    connector.handle_callback("grl_good_key")
+
+    mock_validate.assert_called_once_with("grl_good_key")
+    stored = json.loads(Path(connector._credentials_path).read_text())
+    assert stored["token"] == "grl_good_key"
+
+
+def test_handle_callback_invalid_key_does_not_overwrite_existing(connector) -> None:
+    """A bad key must not clobber an existing, working credential on disk."""
+    from openjarvis.connectors.granola import GranolaKeyError  # noqa: PLC0415
+
+    creds_path = Path(connector._credentials_path)
+    creds_path.write_text(json.dumps({"token": "grl_real_existing_key"}))
+
+    with patch(
+        "openjarvis.connectors.granola.httpx.get",
+        return_value=_FakeResponse(401),
+    ):
+        with pytest.raises(GranolaKeyError):
+            connector.handle_callback("fake-key-12345")
+
+    # The pre-existing credential must be untouched.
+    stored = json.loads(creds_path.read_text())
+    assert stored["token"] == "grl_real_existing_key"

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/tests/connectors/test_slack_connector.py

@@ -560,3 +560,63 @@ def test_sync_logs_per_type_channel_counts(
     assert "1 private channels" in summary
     assert "2 DMs" in summary
     assert "1 group DMs" in summary
+
+
+# ---------------------------------------------------------------------------
+# Test — handle_callback verifies the token with a live auth.test BEFORE it
+# persists anything, so a syntactically-valid-but-dead token is rejected at
+# connect time instead of overwriting a working credential on disk.
+# ---------------------------------------------------------------------------
+
+
+@patch("openjarvis.connectors.slack_connector._slack_api_auth_test")
+def test_handle_callback_persists_after_auth_test_succeeds(
+    mock_auth, connector
+) -> None:
+    """A valid xoxp- token is persisted only after auth.test returns ok."""
+    mock_auth.return_value = _AUTH_TEST_RESPONSE
+
+    connector.handle_callback("xoxp-valid-user-token")
+
+    mock_auth.assert_called_once_with("xoxp-valid-user-token")
+    stored = json.loads(Path(connector._credentials_path).read_text())
+    assert stored["token"] == "xoxp-valid-user-token"
+
+
+@patch("openjarvis.connectors.slack_connector._slack_api_auth_test")
+def test_handle_callback_rejects_when_auth_test_fails(mock_auth, connector) -> None:
+    """A well-formed token Slack rejects (auth.test not ok) is never written."""
+    from openjarvis.connectors.slack_connector import SlackTokenError  # noqa: PLC0415
+
+    mock_auth.return_value = {"ok": False, "error": "invalid_auth"}
+
+    with pytest.raises(SlackTokenError) as excinfo:
+        connector.handle_callback("xoxp-revoked-token")
+
+    assert "invalid_auth" in str(excinfo.value)
+    assert not Path(connector._credentials_path).exists()
+
+
+@patch("openjarvis.connectors.slack_connector._slack_api_auth_test")
+def test_handle_callback_skips_auth_test_for_bad_shape(mock_auth, connector) -> None:
+    """Shape validation short-circuits before any network call is made."""
+    from openjarvis.connectors.slack_connector import SlackTokenError  # noqa: PLC0415
+
+    with pytest.raises(SlackTokenError):
+        connector.handle_callback("xoxb-bot-token")
+
+    mock_auth.assert_not_called()
+    assert not Path(connector._credentials_path).exists()
+
+
+def test_handle_callback_xoxb_message_wording(connector) -> None:
+    """The xoxb- rejection carries the user-facing 'can't read DMs' guidance."""
+    from openjarvis.connectors.slack_connector import SlackTokenError  # noqa: PLC0415
+
+    with pytest.raises(SlackTokenError) as excinfo:
+        connector.handle_callback("xoxb-bot-token")
+
+    assert str(excinfo.value) == (
+        "Bot tokens (xoxb-) can't read DMs. "
+        "Use a User OAuth Token (xoxp-) instead."
+    )

{openjarvis-1.0.3.dev717 → openjarvis-1.0.3.dev719}/tests/server/test_connectors_router.py

@@ -102,3 +102,60 @@ def test_trigger_sync(app, tmp_path: Path) -> None:
     data = resp.json()
     assert data["connector_id"] == "obsidian"
     assert data["status"] in {"started", "already_syncing"}
+
+
+# ---------------------------------------------------------------------------
+# Connect-time credential validation (GH #409): the /connect endpoint must
+# reject invalid credentials with HTTP 400 and never persist (or overwrite)
+# anything on disk when validation fails.
+# ---------------------------------------------------------------------------
+
+
+def test_connect_slack_bot_token_returns_400(app, tmp_path: Path) -> None:
+    """POST connect with an xoxb- token is rejected 400 and writes nothing."""
+    from openjarvis.connectors.slack_connector import SlackConnector
+    from openjarvis.server.connectors_router import _instances
+
+    creds = tmp_path / "slack.json"
+    _instances["slack"] = SlackConnector(credentials_path=str(creds))
+    try:
+        resp = app.post(
+            "/v1/connectors/slack/connect", json={"token": "xoxb-fake-token"}
+        )
+        assert resp.status_code == 400
+        assert "xoxb" in resp.json()["detail"].lower()
+        assert not creds.exists()
+    finally:
+        _instances.pop("slack", None)
+
+
+def test_connect_granola_invalid_key_returns_400_keeps_existing(
+    app, tmp_path: Path
+) -> None:
+    """A bad Granola key is rejected 400 and the existing credential survives."""
+    import json
+    from unittest.mock import patch
+
+    from openjarvis.connectors.granola import GranolaConnector, GranolaKeyError
+    from openjarvis.server.connectors_router import _instances
+
+    creds = tmp_path / "granola.json"
+    creds.write_text(json.dumps({"token": "grl_real_existing_key"}))
+    _instances["granola"] = GranolaConnector(credentials_path=str(creds))
+    try:
+        with patch(
+            "openjarvis.connectors.granola._granola_api_validate_key",
+            side_effect=GranolaKeyError(
+                "Invalid API key. Check your key in Granola Settings → API."
+            ),
+        ):
+            resp = app.post(
+                "/v1/connectors/granola/connect",
+                json={"code": "fake-key-12345"},
+            )
+        assert resp.status_code == 400
+        assert "Invalid API key" in resp.json()["detail"]
+        # The previously-working credential must be untouched.
+        assert json.loads(creds.read_text())["token"] == "grl_real_existing_key"
+    finally:
+        _instances.pop("granola", None)