Skip to content

AI-powered virtual executive team — a single coherent executive persona backed by 8 specialist agents (FastAPI + Next.js).

21.5 KB
Raw Blame
"""App control from chat (orchestrator/app_control.py and its catalog): the
Executive does what the app's buttons do, through the same routes, and leaves
a card for anything that waits for a tap (api/routes/decisions.py)."""
from __future__ import annotations

import asyncio
import json
from collections.abc import Iterator
from datetime import UTC, datetime, timedelta
from pathlib import Path
from typing import Any

import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient

from openexecutive.api.routes import chat as chat_route
from openexecutive.api.routes import decisions as decisions_route
from openexecutive.api.routes import sessions as sessions_route
from openexecutive.departments import registry as dept_registry
from openexecutive.departments import store as dept_store
from openexecutive.memory import decision_ledger, episodic, session_store
from openexecutive.monitoring import store as monitoring_store
from openexecutive.orchestrator import app_control, app_control_catalog, outside_content
from openexecutive.orchestrator.action_chips import summarize_action
from openexecutive.orchestrator.schedule_tools import set_session
from openexecutive.orchestrator.session import Session
from openexecutive.people import registry as people_registry
from openexecutive.people import store as people_store

OWNER = {"x-caller-email": "[email protected]"}
BEN = {"x-caller-email": "[email protected]"}


@pytest.fixture(autouse=True)
def db(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Iterator[Path]:
    # Stores that bind ./episodic_memory.db as a default argument find it here.
    monkeypatch.chdir(tmp_path)
    path = Path("./episodic_memory.db").resolve()
    monkeypatch.setattr(episodic, "DB_PATH", path)
    monkeypatch.setattr(session_store, "DB_PATH", path)
    monkeypatch.setattr(people_store, "DB_PATH", path)
    monkeypatch.setattr(decision_ledger, "_db_path", lambda: path)
    monkeypatch.setattr(dept_store, "DB_PATH", path)
    episodic.initialize_db(path)
    dept_store.initialize_db(path)
    monitoring_store.initialize_db(path)
    dept_registry.invalidate()
    people_store.initialize_db(path)
    for var in ("OE_LOCAL_LOGIN", "OE_PUBLIC_DEPLOYMENT", "BACKEND_SHARED_SECRET"):
        monkeypatch.delenv(var, raising=False)
    monkeypatch.setattr("openexecutive.audit.log_event", lambda *_a, **_k: None)
    chat_route._sessions.clear()
    chat_route._session_starters.clear()
    people_registry.invalidate()
    yield path
    people_registry.invalidate()


@pytest.fixture
def roster() -> dict[str, Any]:
    owner = people_store.upsert_person(full_name="Olivia Owner", is_principal=True, email="[email protected]")
    ben = people_store.upsert_person(full_name="Ben Teammate", email="[email protected]")
    people_registry.invalidate()
    return {"owner": people_store.get_person(owner), "ben": people_store.get_person(ben)}


@pytest.fixture
def client() -> Iterator[TestClient]:
    app = FastAPI()
    app.include_router(sessions_route.router)
    app.include_router(decisions_route.router)
    with TestClient(app) as c:
        yield c


def _chat(owner_id: int, sid: str, title: str) -> str:
    session_store.create_session(sid, title, "2026-10-01T09:00:00+00:00", caller_person_id=owner_id)
    session_store.save_message(sid, "user", "question", sender_person_id=owner_id)
    return sid


def _web(person: Any, session_id: str) -> Session:
    return Session(session_id=session_id, from_web_chat=True, caller_person_id=person.id,
                   web_caller_signed_in=True)


def _run(handler: Any, args: dict[str, Any], session: Session | None) -> dict[str, Any]:
    async def go() -> str:
        if session is None:
            return str(await handler(args))
        with set_session(session):
            return str(await handler(args))

    return dict(json.loads(asyncio.run(go())))


def _meta(sid: str) -> dict[str, Any] | None:
    return session_store.get_session_metadata(sid)


# --------------------------------------------------------------------------- #
# Doing it now
# --------------------------------------------------------------------------- #


def test_pin_and_rename_this_chat(roster: dict[str, Any]) -> None:
    sid = _chat(roster["owner"].id, "s-1", "Old name")
    session = _web(roster["owner"], sid)
    out = _run(app_control.handle_do_in_app, {"action": "pin_chat", "id": "this"}, session)
    assert out == {"status": "done", "did": "Pinned “Old name”"}
    assert (_meta(sid) or {}).get("pinned_at")
    out = _run(app_control.handle_do_in_app, {"action": "rename_chat", "id": "this", "value": "Q3 plan"}, session)
    assert out["status"] == "done"
    assert (_meta(sid) or {})["title"] == "Q3 plan"


def test_find_lists_only_the_speakers_chats(roster: dict[str, Any]) -> None:
    _chat(roster["owner"].id, "s-own", "Pricing review")
    _chat(roster["ben"].id, "s-ben", "Ben's pricing notes")
    out = _run(app_control.handle_find_in_app, {"kind": "chat", "query": "pricing"},
               _web(roster["owner"], "s-own"))
    assert [i["id"] for i in out["items"]] == ["s-own"]


def test_someone_elses_chat_is_not_there(roster: dict[str, Any]) -> None:
    sid = _chat(roster["owner"].id, "s-owner", "Board prep")
    out = _run(app_control.handle_do_in_app, {"action": "rename_chat", "id": sid, "value": "mine now"},
               _web(roster["ben"], "s-x"))
    assert "error" in out
    assert (_meta(sid) or {})["title"] == "Board prep"


def test_nobody_verified_is_refused(roster: dict[str, Any]) -> None:
    sid = _chat(roster["owner"].id, "s-1", "Board prep")
    assert "error" in _run(app_control.handle_do_in_app, {"action": "pin_chat", "id": sid}, None)
    unverified = Session(session_id="s-mail", origin_channel="email")
    assert "error" in _run(app_control.handle_do_in_app, {"action": "pin_chat", "id": sid}, unverified)


def test_owner_only_kinds_are_refused_for_a_teammate(roster: dict[str, Any]) -> None:
    out = _run(app_control.handle_find_in_app, {"kind": "department"}, _web(roster["ben"], "s-b"))
    assert "error" in out
    out = _run(app_control.handle_do_in_app, {"action": "add_department", "id": "new", "value": "Ops"},
               _web(roster["ben"], "s-b"))
    assert "error" in out


def test_a_value_is_required_where_the_action_takes_one(roster: dict[str, Any]) -> None:
    sid = _chat(roster["owner"].id, "s-1", "Board prep")
    out = _run(app_control.handle_do_in_app, {"action": "rename_chat", "id": sid}, _web(roster["owner"], sid))
    assert "needs a value" in out["error"]


def test_a_route_refusal_comes_back_in_words(roster: dict[str, Any]) -> None:
    sid = _chat(roster["owner"].id, "s-1", "Board prep")
    out = _run(app_control.handle_do_in_app, {"action": "rename_chat", "id": sid, "value": "   "},
               _web(roster["owner"], sid))
    assert "error" in out


# --------------------------------------------------------------------------- #
# Waiting for a tap
# --------------------------------------------------------------------------- #


def _card(decision_id: int) -> decision_ledger.DecisionInstance:
    found = decision_ledger.get_decision_instance(decision_id)
    assert found is not None
    return found


def test_delete_leaves_a_card_and_the_tap_deletes(roster: dict[str, Any], client: TestClient) -> None:
    sid = _chat(roster["owner"].id, "s-del", "Old pricing")
    out = _run(app_control.handle_do_in_app, {"action": "delete_chat", "id": "this"}, _web(roster["owner"], sid))
    assert out["status"] == "waiting_for_approval"
    assert out["card"] == "Delete the chat “Old pricing”"
    assert _meta(sid) is not None  # nothing happened yet
    card = _card(out["decision_id"])
    assert card.decision_class == "app_action"
    assert card.approver_person_id == roster["owner"].id

    # Nobody else sees or answers it.
    assert client.get(f"/decisions/{card.id}", headers=BEN).status_code == 404
    assert client.post(f"/decisions/{card.id}/approve", json={}, headers=BEN).status_code == 404

    res = client.post(f"/decisions/{card.id}/approve", json={}, headers=OWNER)
    assert res.status_code == 200, res.text
    assert res.json()["status"] == decision_ledger.STATUS_APPROVED_UNCHANGED
    assert _meta(sid) is None
    # Once only.
    assert client.post(f"/decisions/{card.id}/approve", json={}, headers=OWNER).status_code == 409


def test_dismissing_the_card_does_nothing(roster: dict[str, Any], client: TestClient) -> None:
    sid = _chat(roster["owner"].id, "s-keep", "Keep me")
    out = _run(app_control.handle_do_in_app, {"action": "delete_chat", "id": sid}, _web(roster["owner"], sid))
    res = client.post(f"/decisions/{out['decision_id']}/reject", json={}, headers=OWNER)
    assert res.status_code == 200
    assert _meta(sid) is not None


def test_a_stale_card_is_turned_down(roster: dict[str, Any], client: TestClient) -> None:
    sid = _chat(roster["owner"].id, "s-old", "Old")
    out = _run(app_control.handle_do_in_app, {"action": "delete_chat", "id": sid}, _web(roster["owner"], sid))
    old = (datetime.now(UTC) - timedelta(days=2)).isoformat()
    with episodic._get_conn() as conn:
        conn.execute("UPDATE decision_instances SET created_at = ? WHERE id = ?", (old, out["decision_id"]))
    res = client.post(f"/decisions/{out['decision_id']}/approve", json={}, headers=OWNER)
    assert res.status_code == 409
    assert _meta(sid) is not None


def test_a_refusal_on_the_tap_is_recorded(roster: dict[str, Any], client: TestClient) -> None:
    sid = _chat(roster["owner"].id, "s-gone", "Gone")
    out = _run(app_control.handle_do_in_app, {"action": "delete_chat", "id": sid}, _web(roster["owner"], sid))
    session_store.delete_session(sid)
    res = client.post(f"/decisions/{out['decision_id']}/approve", json={}, headers=OWNER)
    assert res.status_code == 404
    assert _card(out["decision_id"]).status == decision_ledger.STATUS_FAILED


def test_after_an_outside_read_everything_waits(roster: dict[str, Any]) -> None:
    sid = _chat(roster["owner"].id, "s-out", "Board prep")
    session = _web(roster["owner"], sid)
    state = outside_content.begin_turn(session)
    try:
        outside_content.mark("read_document")
        out = _run(app_control.handle_do_in_app, {"action": "rename_chat", "id": sid, "value": "pwned"}, session)
    finally:
        outside_content.end_turn(state)
    assert out["status"] == "waiting_for_approval"
    assert (_meta(sid) or {})["title"] == "Board prep"


def test_turning_on_act_as_me_waits_but_off_does_not() -> None:
    action = app_control.CATALOG.actions["change_setting"]
    assert action.needs_tap("act_as_me", "on")
    assert action.needs_tap("handle_it", "on")
    assert action.needs_tap("take_the_lead", "yes")
    assert not action.needs_tap("handle_it", "off")
    assert not action.needs_tap("quiet_hours", "22:00-07:00")


def test_sharing_waits_for_a_tap(roster: dict[str, Any], client: TestClient) -> None:
    sid = _chat(roster["owner"].id, "s-share", "Hiring plan")
    out = _run(app_control.handle_do_in_app, {"action": "share_chat", "id": sid, "value": "Ben"},
               _web(roster["owner"], sid))
    assert out["card"] == "Share the chat “Hiring plan” with Ben"
    res = client.post(f"/decisions/{out['decision_id']}/approve", json={}, headers=OWNER)
    assert res.status_code == 200, res.text
    assert [r["person_id"] for r in session_store.shared_with(sid)] == [roster["ben"].id]


# --------------------------------------------------------------------------- #
# Topics, settings, links, chips, the catalog
# --------------------------------------------------------------------------- #


def test_file_a_chat_under_a_topic_then_rename_the_topic(roster: dict[str, Any]) -> None:
    sid = _chat(roster["owner"].id, "s-t", "Lease terms")
    session = _web(roster["owner"], sid)
    assert _run(app_control.handle_do_in_app,
                {"action": "move_chat_to_topic", "id": "this", "value": "Main St property"}, session)["status"] == "done"
    found = _run(app_control.handle_find_in_app, {"kind": "topic"}, session)["items"]
    assert [t["title"] for t in found] == ["Main St property"]
    out = _run(app_control.handle_do_in_app,
               {"action": "rename_topic", "id": found[0]["id"], "value": "Main Street"}, session)
    assert out == {"status": "done", "did": "Renamed the topic “Main Street”"}


def test_quiet_hours_from_chat(roster: dict[str, Any], monkeypatch: pytest.MonkeyPatch) -> None:
    from openexecutive.people import notifications

    monkeypatch.setattr(notifications, "DB_PATH", Path("./episodic_memory.db").resolve(), raising=False)
    session = _web(roster["owner"], "s-q")
    out = _run(app_control.handle_do_in_app,
               {"action": "change_setting", "id": "quiet_hours", "value": "21:30-06:45"}, session)
    assert out == {"status": "done", "did": "Set Quiet hours to 21:30-06:45"}, out
    saved = notifications.get_notification_settings(roster["owner"].id)
    assert (saved.quiet_hours.enabled, saved.quiet_hours.start, saved.quiet_hours.end) == (True, "21:30", "06:45")


def test_open_in_app_gives_an_app_link() -> None:
    out = _run(app_control.handle_open_in_app, {"screen": "notifications"}, None)
    assert out == {"status": "link", "link": "/settings/notifications", "screen": "Settings, Notifications"}
    assert "error" in _run(app_control.handle_open_in_app, {"screen": "https://evil.example"}, None)
    with pytest.raises(ValueError):
        app_control.register_screen("evil", "https://evil.example", "x")


def test_chips() -> None:
    done = summarize_action(tool_name="do_in_app", tool_input={},
                            tool_result=json.dumps({"status": "done", "did": "Pinned “Q3”"}))
    assert done is not None and done["summary"] == "Pinned “Q3”"
    waiting = summarize_action(
        tool_name="do_in_app", tool_input={},
        tool_result=json.dumps({"status": "waiting_for_approval", "decision_id": 7, "card": "Delete the chat “Q3”"}),
    )
    assert waiting is not None
    assert waiting["summary"] == "Waiting for your OK: Delete the chat “Q3”"
    assert waiting["decision_id"] == 7
    assert summarize_action(tool_name="do_in_app", tool_input={}, tool_result=json.dumps({"error": "no"})) is None
    link = summarize_action(tool_name="open_in_app", tool_input={},
                            tool_result=json.dumps({"status": "link", "link": "/today", "screen": "Today"}))
    assert link is not None and link["link"] == "/today"
    assert summarize_action(tool_name="open_in_app", tool_input={},
                            tool_result=json.dumps({"status": "link", "link": "//evil.example"})) is None


def test_the_catalog_is_whole() -> None:
    catalog = app_control.CATALOG
    assert app_control_catalog  # installed on import
    for action in catalog.actions.values():
        assert action.kind in catalog.kinds
        if action.needs_tap("x", "on"):
            assert action.card, action.name
    schema = app_control.DO_IN_APP_TOOL["input_schema"]["properties"]["action"]["enum"]
    assert schema == sorted(name for name, action in catalog.actions.items() if not action.hidden)
    for name in ("pin_chat", "rename_chat", "delete_chat"):
        assert name in app_control.DO_IN_APP_TOOL["description"]
    for name, action in catalog.actions.items():
        destructive = name.startswith("delete_") or name.startswith("share_")
        if destructive:
            assert action.needs_tap("x", ""), name


def test_registering_twice_is_refused() -> None:
    with pytest.raises(ValueError):
        app_control.register_action(app_control.CATALOG.actions["pin_chat"])


def test_departments_add_rename_and_delete(roster: dict[str, Any], client: TestClient) -> None:
    session = _web(roster["owner"], "s-d")
    out = _run(app_control.handle_do_in_app, {"action": "add_department", "id": "new", "value": "Field Ops"}, session)
    assert out == {"status": "done", "did": "Added the department “Field Ops”"}, out
    found = _run(app_control.handle_find_in_app, {"kind": "department", "query": "field"}, session)["items"]
    assert [d["title"] for d in found] == ["Field Ops"]
    slug = found[0]["id"]
    out = _run(app_control.handle_do_in_app, {"action": "rename_department", "id": slug, "value": "Field"}, session)
    assert out["status"] == "done", out
    out = _run(app_control.handle_do_in_app, {"action": "delete_department", "id": slug}, session)
    assert out["card"] == "Delete the department “Field”"
    res = client.post(f"/decisions/{out['decision_id']}/approve", json={}, headers=OWNER)
    assert res.status_code == 200, res.text
    assert _run(app_control.handle_find_in_app, {"kind": "department", "query": "field"}, session)["items"] == []


def test_memory_edit_and_delete(roster: dict[str, Any], client: TestClient) -> None:
    episodic.store_decision("sales", "Raise prices 5%")
    decision_id = episodic.list_decisions()[0].id
    session = _web(roster["owner"], "s-m")
    found = _run(app_control.handle_find_in_app, {"kind": "memory", "query": "prices"}, session)["items"]
    assert found == [{"id": f"decision:{decision_id}", "title": "Raise prices 5%", "detail": "decision"}]
    out = _run(app_control.handle_do_in_app,
               {"action": "edit_memory", "id": f"decision:{decision_id}", "value": "Raise prices 7%"}, session)
    assert out["status"] == "done", out
    out = _run(app_control.handle_do_in_app, {"action": "delete_memory", "id": f"decision:{decision_id}"}, session)
    assert out["status"] == "waiting_for_approval"
    assert client.post(f"/decisions/{out['decision_id']}/approve", json={}, headers=OWNER).status_code == 200
    assert _run(app_control.handle_find_in_app, {"kind": "memory"}, session)["items"] == []


@pytest.mark.parametrize("kind", sorted(k for k, v in app_control.CATALOG.kinds.items() if not v.no_item))
def test_every_list_reads(kind: str, roster: dict[str, Any], monkeypatch: pytest.MonkeyPatch) -> None:
    from openexecutive.knowledge import store as knowledge_store

    class _Store:
        def __init__(self, *_a: Any, **_k: Any) -> None: ...

        def __getattr__(self, _name: str) -> Any:
            return lambda *_a, **_k: {}

    monkeypatch.setattr(knowledge_store, "ChromaDBStore", _Store)
    out = _run(app_control.handle_find_in_app, {"kind": kind}, _web(roster["owner"], "s-k"))
    assert "items" in out, out


def test_topic_pin_merge_and_remove(roster: dict[str, Any]) -> None:
    owner = roster["owner"]
    session = _web(owner, "s-a")
    for sid, topic in (("s-a", "Leases"), ("s-b", "Lease terms")):
        _chat(owner.id, sid, sid)
        _run(app_control.handle_do_in_app, {"action": "move_chat_to_topic", "id": sid, "value": topic}, session)
    topics = {t["title"]: t["id"] for t in _run(app_control.handle_find_in_app, {"kind": "topic"}, session)["items"]}
    assert _run(app_control.handle_do_in_app, {"action": "pin_topic", "id": topics["Leases"]}, session)["status"] == "done"
    out = _run(app_control.handle_do_in_app,
               {"action": "merge_topic", "id": topics["Lease terms"], "value": "Leases"}, session)
    assert out == {"status": "done", "did": "Moved the chats in “Lease terms” into “Leases”"}, out
    out = _run(app_control.handle_do_in_app, {"action": "remove_topic", "id": topics["Leases"]}, session)
    assert out["status"] == "done", out
    assert _meta("s-a") is not None and _meta("s-b") is not None


def test_settings_and_lead_rules(roster: dict[str, Any], client: TestClient) -> None:
    session = _web(roster["owner"], "s-s")
    out = _run(app_control.handle_do_in_app, {"action": "change_setting", "id": "delivery", "value": "digest"}, session)
    assert out == {"status": "done", "did": "Set How messages arrive (instant or digest) to digest"}, out
    out = _run(app_control.handle_do_in_app, {"action": "change_setting", "id": "act_as_me", "value": "off"}, session)
    assert out["status"] == "done", out
    out = _run(app_control.handle_do_in_app, {"action": "change_setting", "id": "act_as_me", "value": "on"}, session)
    assert out["status"] == "waiting_for_approval"
    out = _run(app_control.handle_do_in_app,
               {"action": "add_lead_rule", "id": "new", "value": "domain: acme.com"}, session)
    assert out["status"] == "done", out
    rules = _run(app_control.handle_find_in_app, {"kind": "lead_rule"}, session)["items"]
    assert [r["title"] for r in rules] == ["domain: acme.com"]
    out = _run(app_control.handle_do_in_app, {"action": "remove_lead_rule", "id": rules[0]["id"]}, session)
    assert out["status"] == "waiting_for_approval"


def test_every_card_names_what_it_changes() -> None:
    # After outside content is read any action can become a card: each one
    # says which item and what new value, so the tap does what it shows.
    for action in app_control.CATALOG.actions.values():
        kind = app_control.CATALOG.kinds[action.kind]
        text = app_control.card_text(action, "Item X", "Value Y")
        if not kind.no_item:
            assert "Item X" in text, action.name
        if action.value:
            assert "Value Y" in text, action.name


def test_a_shared_chat_gets_no_list_and_no_change(roster: dict[str, Any]) -> None:
    sid = _chat(roster["owner"].id, "s-shared", "Board prep")
    session = _web(roster["owner"], sid)
    session.shared_chat = True
    out = _run(app_control.handle_find_in_app, {"kind": "chat"}, session)
    assert "error" in out and "items" not in out
    out = _run(app_control.handle_do_in_app, {"action": "rename_chat", "id": sid, "value": "x"}, session)
    assert "error" in out
    assert (_meta(sid) or {})["title"] == "Board prep"


def test_a_chat_turn_never_counts_as_a_signed_request() -> None:
    from openexecutive.api.caller import Caller
    from openexecutive.delegation import verified

    with verified.from_chat():
        assert verified.caller_refusal(Caller("user", "[email protected]"), "[email protected]") is not None