feat: infrance

.env.example

@@ -1,9 +1,18 @@
+MODEL_PROVIDER=ollama
 OLLAMA_BASE_URL=http://localhost:11434
 OLLAMA_MODEL=qwen3.5:9b
 OLLAMA_NUM_CTX=64512
+OPENAI_BASE_URL=https://api.openai.com/v1
+OPENAI_MODEL=gpt-5.4-mini
+OPENAI_API_KEY=
+MODEL_REASONING_EFFORT=medium
+CODEX_COMMAND=codex
+CODEX_MODEL=gpt-5.4
 UEX_BASE_URL=https://api.uexcorp.space/2.0
 SCMDB_BASE_URL=https://scmdb.net
 CORNERSTONE_BASE_URL=https://finder.cstone.space
+SCWIKI_BASE_URL=https://starcitizen.tools
+SCWIKI_API_BASE_URL=https://api.star-citizen.wiki
 UEX_SECRET_KEY=
 UEX_BEARER_TOKEN=
 TRADERAI_USER_NAME=

README.md

@@ -1,6 +1,6 @@
 # TraderAI
 
-Local Ollama-powered chat for UEX marketplace workflows.
+Local Ollama-, OpenAI-, or Codex-powered chat for UEX marketplace workflows.
 
 ## What It Does
 
@@ -25,6 +25,9 @@ Local Ollama-powered chat for UEX marketplace workflows.
    ```
 
 3. Create `.env` from `.env.example` and set `UEX_SECRET_KEY` and/or `UEX_BEARER_TOKEN` if you want authenticated actions.
+   If you want to use OpenAI instead of Ollama, set `MODEL_PROVIDER=openai`, set `OPENAI_API_KEY`, and optionally change `OPENAI_MODEL` from the default `gpt-5.4-mini`.
+   If you want to use Codex models with ChatGPT/Codex OAuth, install the Codex CLI, set `MODEL_PROVIDER=codex`, and optionally change `CODEX_MODEL` from the default `gpt-5.4`. TraderAI uses the local `codex app-server` JSON-RPC interface for both authentication and chat turns.
+   `MODEL_REASONING_EFFORT` controls reasoning depth for OpenAI and Codex and defaults to `medium`.
    `SCMDB_BASE_URL` defaults to `https://scmdb.net`.
    `CORNERSTONE_BASE_URL` defaults to `https://finder.cstone.space`.
 4. Install and run:
@@ -38,7 +41,7 @@ Local Ollama-powered chat for UEX marketplace workflows.
 
 ## Notes
 
-Ollama runs locally at `http://localhost:11434` by default. This app talks to Ollama's native chat API with tool schemas, then executes approved UEX calls in the FastAPI backend. `OLLAMA_NUM_CTX` controls the per-request Ollama context window; `64512` is the default because Ollama recommends at least 64k tokens for agent-style workflows when hardware allows it.
+Ollama runs locally at `http://localhost:11434` by default. This app can talk to Ollama's native chat API, OpenAI's Chat Completions API, or the local Codex App Server authenticated through ChatGPT/Codex OAuth, then executes approved UEX calls in the FastAPI backend. `OLLAMA_NUM_CTX` controls the per-request Ollama context window; `64512` is the default because Ollama recommends at least 64k tokens for agent-style workflows when hardware allows it.
 
 ## Releases And Updates
 

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "traderai"
-version = "0.0.3"
+version = "0.0.6"
-description = "Local Ollama-powered assistant for UEX marketplace workflows."
+description = "Local Ollama, OpenAI, or Codex assistant for UEX marketplace workflows."
 requires-python = ">=3.11"
 dependencies = [
   "apscheduler>=3.10.4",
@@ -37,3 +37,7 @@ include = ["traderai*"]
 
 
 
+
+
+
+

tests/test_agent.py

@@ -64,6 +64,19 @@ class TitleAgent(OllamaAgent):
         return {"message": {"role": "assistant", "content": "Done"}}
 
 
+class ImageCaptureAgent(OllamaAgent):
+    def __init__(self, memory):
+        super().__init__("http://127.0.0.1:1", "missing-model", EmptyTools(), memory=memory)
+        self.last_messages = None
+
+    async def ensure_available(self):
+        return None
+
+    async def _chat_once(self, query="", messages=None, **kwargs):
+        self.last_messages = messages
+        return {"message": {"role": "assistant", "content": "Seen"}}
+
+
 class SlowToolTools(EmptyTools):
     schemas = [
         {
@@ -204,6 +217,90 @@ def test_ollama_options_include_num_ctx():
     assert agent._ollama_options() == {"num_ctx": 64000}
 
 
+def test_codex_prompt_mentions_tools_and_images(tmp_path):
+    memory = MemoryStore(str(tmp_path / "memory.sqlite3"))
+    agent = OllamaAgent("codex", "gpt-5.3-codex", EmptyTools(), memory=memory, provider="codex")
+
+    prompt = agent._codex_cli_prompt(
+        "check listing",
+        [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": "Look at this",
+                "images": ["ZmFrZQ=="],
+                "image_content_types": ["image/png"],
+            },
+            {
+                "role": "assistant",
+                "content": "",
+                "tool_calls": [
+                    {
+                        "id": "call_123",
+                        "type": "function",
+                        "function": {"name": "search_marketplace_listings", "arguments": "{\"commodity\":\"gold\"}"},
+                    }
+                ],
+            },
+            {
+                "role": "tool",
+                "tool_name": "search_marketplace_listings",
+                "tool_call_id": "call_123",
+                "content": "{\"ok\":true}",
+            },
+        ],
+    )
+
+    assert "Available tools" in prompt
+    assert "attached images: 1" in prompt
+    assert "search_marketplace_listings" in prompt
+    assert "tool search_marketplace_listings" in prompt
+
+
+def test_codex_structured_response_extracts_text_and_tool_calls():
+    agent = OllamaAgent("codex", "gpt-5.3-codex", EmptyTools(), provider="codex")
+
+    result = agent._codex_structured_response(
+        {
+            "kind": "tool_call",
+            "message": "",
+            "tool_name": "search_marketplace_listings",
+            "arguments_json": "{\"commodity\":\"gold\"}",
+        }
+    )
+
+    assert result["message"]["content"] == ""
+    assert result["message"]["tool_calls"] == [
+        {
+            "id": result["message"]["tool_calls"][0]["id"],
+            "type": "function",
+            "function": {
+                "name": "search_marketplace_listings",
+                "arguments": "{\"commodity\":\"gold\"}",
+            },
+        }
+    ]
+
+
+def test_parse_codex_exec_output_reads_final_json():
+    agent = OllamaAgent("codex", "gpt-5.3-codex", EmptyTools(), provider="codex")
+
+    result = agent._parse_codex_exec_output(
+        {
+            "returncode": 0,
+            "stdout": "",
+            "stderr": "",
+            "events": [
+                {"type": "thread.started", "thread_id": "abc"},
+                {"type": "item.completed", "item": {"type": "agent_message", "text": "{\"kind\":\"final\",\"message\":\"hello\",\"tool_name\":\"\",\"arguments_json\":\"{}\"}"}},
+                {"type": "turn.completed"},
+            ],
+        }
+    )
+
+    assert result == {"kind": "final", "message": "hello", "tool_name": "", "arguments_json": "{}"}
+
+
 @pytest.mark.asyncio
 async def test_wake_response_executes_tool_calls(tmp_path):
     memory = MemoryStore(str(tmp_path / "memory.sqlite3"))
@@ -229,6 +326,23 @@ async def test_first_chat_message_generates_thread_title(tmp_path):
     assert memory.get_thread(thread["id"])["title"] == "UEX Market Check"
 
 
+@pytest.mark.asyncio
+async def test_chat_includes_pasted_images_and_memory_note(tmp_path):
+    memory = MemoryStore(str(tmp_path / "memory.sqlite3"))
+    agent = ImageCaptureAgent(memory)
+
+    result = await agent.chat(
+        "",
+        images=[{"name": "listing.png", "content_type": "image/png", "image_data": "ZmFrZS1pbWFnZQ=="}],
+    )
+
+    assert result["message"] == "Seen"
+    user_message = next(message for message in reversed(agent.last_messages) if message.get("role") == "user")
+    assert user_message["images"] == ["ZmFrZS1pbWFnZQ=="]
+    assert user_message["content"] == "Please analyze the attached image."
+    assert "[Attached 1 pasted image]" in memory.recent_conversation()[-2]["content"]
+
+
 @pytest.mark.asyncio
 async def test_chat_events_returns_fallback_after_slow_tool_and_empty_final_response(tmp_path):
     memory = MemoryStore(str(tmp_path / "memory.sqlite3"))

tests/test_config.py

@@ -0,0 +1,25 @@
+from traderai.config import Settings
+
+
+def test_model_provider_accepts_codex():
+    settings = Settings(model_provider="codex")
+
+    assert settings.model_provider == "codex"
+
+
+def test_model_provider_invalid_value_falls_back_to_ollama():
+    settings = Settings(model_provider="something-else")
+
+    assert settings.model_provider == "ollama"
+
+
+def test_reasoning_effort_normalizes_invalid_values():
+    settings = Settings(model_reasoning_effort="whatever")
+
+    assert settings.model_reasoning_effort == "medium"
+
+
+def test_reasoning_effort_accepts_supported_values():
+    settings = Settings(model_reasoning_effort="high")
+
+    assert settings.model_reasoning_effort == "high"

tests/test_plans.py

@@ -0,0 +1,253 @@
+import pytest
+from datetime import timedelta
+
+from traderai.memory import MemoryStore, utc_now
+from traderai.plans import ContinualPlanRunner, ContinualPlanStore
+from traderai.scheduler import WakeScheduler
+from traderai.tools import ToolRegistry
+
+
+class BuyingUEX:
+    def __init__(self):
+        self.posts = []
+
+    async def get(self, path, params=None, authenticated=False):
+        if path == "marketplace_listings":
+            return {
+                "data": [
+                    {
+                        "id": 501,
+                        "slug": "wikelo-panel-good",
+                        "title": "Wikelo Idris panel",
+                        "operation": "sell",
+                        "type": "item",
+                        "price": 450_000,
+                        "currency": "UEC",
+                        "in_stock": 2,
+                        "location": "Orison",
+                        "user_username": "seller_a",
+                    },
+                    {
+                        "id": 502,
+                        "slug": "wikelo-panel-expensive",
+                        "title": "Wikelo Idris panel premium",
+                        "operation": "sell",
+                        "type": "item",
+                        "price": 900_000,
+                        "currency": "UEC",
+                        "in_stock": 1,
+                        "location": "Area18",
+                        "user_username": "seller_b",
+                    },
+                ],
+            }
+        return {"data": []}
+
+    async def post(self, path, payload, authenticated=True):
+        self.posts.append({"path": path, "payload": payload, "authenticated": authenticated})
+        return {"status": "ok", "posted": self.posts[-1]}
+
+    async def delete(self, path, params=None, authenticated=True):
+        return {"status": "ok"}
+
+
+class FakePlanAgent:
+    def __init__(self):
+        self.prompts = []
+
+    async def generate_wake_response(self, wake_message):
+        self.prompts.append(wake_message)
+        return "Custom plan checked notifications and found no blockers."
+
+
+def plan_stack(tmp_path):
+    memory = MemoryStore(str(tmp_path / "memory.sqlite3"))
+    store = ContinualPlanStore(memory)
+    scheduler = WakeScheduler(memory)
+    tools = ToolRegistry(BuyingUEX(), memory=memory, scheduler=scheduler, plan_store=store)
+    runner = ContinualPlanRunner(store, tools, memory)
+    tools.plan_runner = runner
+    scheduler.bind_plan_runner(runner)
+    return memory, store, tools, runner, scheduler
+
+
+def test_continual_plan_store_creates_needs_input_plan(tmp_path):
+    _, store, _, _, _ = plan_stack(tmp_path)
+
+    plan = store.create_plan("Wikelo Idris", objective="Get all parts", items=[])
+
+    assert plan["status"] == "needs_input"
+    assert plan["items"] == []
+    assert plan["events"][0]["kind"] == "needs_input"
+
+
+def test_custom_plan_without_items_is_active(tmp_path):
+    _, store, _, _, _ = plan_stack(tmp_path)
+
+    plan = store.create_plan("Watch negotiations", kind="custom", objective="Check replies and summarize next steps", items=[])
+
+    assert plan["status"] == "active"
+    assert plan["items"] == []
+
+
+def test_continual_plan_store_creates_buying_checklist(tmp_path):
+    _, store, _, _, _ = plan_stack(tmp_path)
+
+    plan = store.create_plan(
+        "Wikelo Idris",
+        objective="Get all listed parts",
+        items=[{"item_name": "Wikelo Idris panel", "desired_quantity": 2, "max_unit_price": 500_000}],
+    )
+
+    assert plan["status"] == "active"
+    assert plan["items"][0]["item_name"] == "Wikelo Idris panel"
+    assert plan["items"][0]["desired_quantity"] == 2
+
+
+def test_continual_plan_store_deletes_plan_and_related_records(tmp_path):
+    _, store, _, _, _ = plan_stack(tmp_path)
+
+    plan = store.create_plan(
+        "Delete me",
+        objective="Remove everything",
+        items=[{"item_name": "Wikelo Idris panel", "desired_quantity": 1}],
+    )
+    item_id = int(plan["items"][0]["id"])
+    candidate = store.upsert_candidate(plan["id"], item_id, {"id": "listing-1", "title": "Panel", "price": 10}, 0.9)
+    store.add_negotiation(plan["id"], item_id, int(candidate["id"]), {"listing_id": "listing-1", "listing_slug": "panel", "id_negotiation": "neg-1", "hash": "hash-1"})
+
+    assert store.delete_plan(plan["id"]) is True
+    assert store.get_plan(plan["id"]) is None
+    assert store.list_items(plan["id"]) == []
+    assert store.list_candidates(plan["id"]) == []
+    assert store.list_negotiations(plan["id"]) == []
+    assert store.list_events(plan["id"]) == []
+
+
+@pytest.mark.asyncio
+async def test_buying_runner_tracks_candidates_and_drafts_only(tmp_path):
+    memory, store, tools, runner, _ = plan_stack(tmp_path)
+    plan = store.create_plan(
+        "Wikelo Idris",
+        objective="Get all listed parts",
+        items=[{"item_name": "Wikelo Idris panel", "desired_quantity": 1, "max_unit_price": 500_000}],
+    )
+
+    result = await runner.run_plan(plan["id"])
+    snapshot = store.get_plan(plan["id"])
+
+    assert result["drafted"] == 1
+    assert any(candidate["listing_id"] == "501" and candidate["status"] == "drafted" for candidate in snapshot["candidates"])
+    assert snapshot["negotiations"][0]["status"] == "drafted"
+    assert len(tools.pending_actions) == 1
+    assert not tools.uex.posts
+    assert "Drafted 1 negotiation" in memory.list_outbox()[0]["content"]
+
+
+@pytest.mark.asyncio
+async def test_plan_approval_logs_back_to_plan(tmp_path):
+    _, store, tools, runner, _ = plan_stack(tmp_path)
+    plan = store.create_plan(
+        "Wikelo Idris",
+        objective="Get all listed parts",
+        items=[{"item_name": "Wikelo Idris panel", "max_unit_price": 500_000}],
+    )
+    await runner.run_plan(plan["id"])
+    action_id = next(iter(tools.pending_actions))
+
+    approved = await tools.approve(action_id)
+    snapshot = store.get_plan(plan["id"])
+
+    assert approved["posted"]["path"] == "marketplace_negotiations_messages"
+    assert any(event["kind"] == "approved" for event in snapshot["events"])
+    assert any(negotiation["status"] == "approved" for negotiation in snapshot["negotiations"])
+
+
+@pytest.mark.asyncio
+async def test_custom_runner_continues_plan_through_agent(tmp_path):
+    memory, store, tools, runner, _ = plan_stack(tmp_path)
+    agent = FakePlanAgent()
+    runner.bind_agent(agent)
+    plan = store.create_plan(
+        "Watch open negotiations",
+        kind="custom",
+        objective="Check UEX replies and recommend next action",
+        constraints={"instructions": "Pay attention to stale buyer replies."},
+        items=[],
+    )
+
+    result = await runner.run_plan(plan["id"])
+    snapshot = store.get_plan(plan["id"])
+
+    assert result["status"] == "ok"
+    assert "Custom plan checked notifications" in result["summary"]
+    assert plan["id"] in agent.prompts[0]
+    assert any(event["kind"] == "run" for event in snapshot["events"])
+    assert "Custom plan checked notifications" in memory.list_outbox()[0]["content"]
+
+
+@pytest.mark.asyncio
+async def test_scheduler_plan_run_survives_runner_error(tmp_path):
+    memory = MemoryStore(str(tmp_path / "memory.sqlite3"))
+    store = ContinualPlanStore(memory)
+    plan = store.create_plan(
+        "Broken plan",
+        objective="Test failure handling",
+        items=[{"item_name": "Wikelo Idris panel"}],
+    )
+
+    class FailingRunner:
+        def __init__(self, store):
+            self.store = store
+
+        async def run_plan(self, plan_id):
+            self.store.add_event(plan_id, "error", "boom")
+            memory.add_outbox("Broken plan: boom")
+            return {"error": "boom", "plan": self.store.get_plan(plan_id)}
+
+    scheduler = WakeScheduler(memory)
+    scheduler.bind_plan_runner(FailingRunner(store))
+
+    await scheduler._run_plan(plan["id"])
+
+    snapshot = store.get_plan(plan["id"])
+    assert snapshot["status"] == "active"
+    assert snapshot["events"][0]["kind"] == "error"
+    assert "boom" in memory.list_outbox()[0]["content"]
+
+
+@pytest.mark.asyncio
+async def test_scheduler_schedules_overdue_plan_catchup_on_start(tmp_path):
+    memory, store, _, runner, scheduler = plan_stack(tmp_path)
+    plan = store.create_plan(
+        "Overdue plan",
+        objective="Check after restart",
+        items=[{"item_name": "Wikelo Idris panel"}],
+    )
+    store.update_schedule(plan["id"], (utc_now() - timedelta(minutes=5)).isoformat())
+
+    scheduler.start()
+    try:
+        catchup = scheduler.scheduler.get_job(scheduler._plan_catchup_job_id(plan["id"]))
+        snapshot = store.get_plan(plan["id"])
+    finally:
+        scheduler.shutdown()
+
+    assert catchup is not None
+    assert any(event["kind"] == "catchup_scheduled" for event in snapshot["events"])
+
+
+@pytest.mark.asyncio
+async def test_tools_delete_continual_plan_removes_it(tmp_path):
+    _, store, tools, _, _ = plan_stack(tmp_path)
+    plan = store.create_plan(
+        "Delete through tools",
+        objective="Remove via registry",
+        items=[{"item_name": "Wikelo Idris panel"}],
+    )
+
+    result = await tools.delete_continual_plan(plan["id"])
+
+    assert result["deleted"] is True
+    assert result["plan_id"] == plan["id"]
+    assert store.get_plan(plan["id"]) is None

tests/test_server.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from fastapi.testclient import TestClient
+
+import traderai.server as server
+
+
+def test_config_update_rebuilds_runtime_without_restart(monkeypatch, tmp_path):
+    state = {"settings": make_settings(tmp_path, model_provider="ollama", ollama_model="qwen3.5:9b")}
+
+    class FakeScheduler:
+        def __init__(self, memory):
+            self.memory = memory
+
+        def bind_agent(self, agent):
+            self.agent = agent
+
+        def bind_plan_runner(self, plan_runner):
+            self.plan_runner = plan_runner
+
+        def bind_uex_notifications(self, uex, poll_seconds=60):
+            self.uex = uex
+            self.poll_seconds = poll_seconds
+
+        def start(self):
+            return None
+
+        def shutdown(self):
+            return None
+
+        def list_jobs(self):
+            return []
+
+    class FakeUEXClient:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        async def get_user(self, username=None, authenticated=False):
+            return {}
+
+    class FakeToolRegistry:
+        def __init__(self, *args, **kwargs):
+            self.pending_actions = {}
+            self.plan_runner = None
+
+        async def approve(self, action_id):
+            return {"approved": action_id}
+
+        async def decline(self, action_id):
+            return {"declined": action_id}
+
+    class FakePlanRunner:
+        def __init__(self, store, tools, memory, agent=None):
+            self.store = store
+            self.tools = tools
+            self.memory = memory
+            self.agent = agent
+
+        def bind_agent(self, agent):
+            self.agent = agent
+
+    class FakeClient:
+        def __init__(self, *args, **kwargs):
+            pass
+
+    async def fake_health(self):
+        return {
+            "online": True,
+            "provider": self.provider,
+            "model": self.model,
+            "model_available": True,
+            "message": f"{self.provider} ready",
+        }
+
+    async def fake_chat(self, content, thread_id=None, images=None):
+        return {"message": f"{self.provider}:{self.model}", "pending_actions": [], "thread_id": thread_id}
+
+    def fake_get_settings():
+        return state["settings"]
+
+    def fake_save_settings(values):
+        state["settings"] = make_settings(
+            tmp_path,
+            model_provider=values.get("model_provider", state["settings"].model_provider),
+            ollama_model=values.get("ollama_model", state["settings"].ollama_model),
+            codex_model=values.get("codex_model", state["settings"].codex_model),
+        )
+        return {"values": values, "fields": {}, "secrets_configured": {}, "app_data_dir": str(tmp_path)}
+
+    monkeypatch.setattr(server, "WakeScheduler", FakeScheduler)
+    monkeypatch.setattr(server, "UEXClient", FakeUEXClient)
+    monkeypatch.setattr(server, "ToolRegistry", FakeToolRegistry)
+    monkeypatch.setattr(server, "ContinualPlanRunner", FakePlanRunner)
+    monkeypatch.setattr(server, "SCMDBClient", FakeClient)
+    monkeypatch.setattr(server, "CornerstoneClient", FakeClient)
+    monkeypatch.setattr(server, "StarCitizenWikiClient", FakeClient)
+    monkeypatch.setattr(server, "get_settings", fake_get_settings)
+    monkeypatch.setattr(server, "save_settings", fake_save_settings)
+    monkeypatch.setattr(
+        server,
+        "settings_payload",
+        lambda settings=None: {"app_data_dir": str(tmp_path), "values": {}, "fields": {}, "secrets_configured": {}},
+    )
+    monkeypatch.setattr(server.OllamaAgent, "health", fake_health)
+    monkeypatch.setattr(server.OllamaAgent, "chat", fake_chat)
+
+    app = server.create_app()
+    with TestClient(app) as client:
+        before = client.get("/api/health").json()
+        assert before["model_provider"] == "ollama"
+        assert before["inference"]["provider"] == "ollama"
+
+        updated = client.post(
+            "/api/config",
+            json={"values": {"model_provider": "codex", "codex_model": "gpt-5.4"}},
+        ).json()
+        assert updated["restart_required"] is False
+
+        after = client.get("/api/health").json()
+        assert after["model_provider"] == "codex"
+        assert after["inference"]["provider"] == "codex"
+
+        chat = client.post("/api/chat", json={"message": "hi", "thread_id": "thread-1", "images": []}).json()
+        assert chat["message"] == "codex:gpt-5.4"
+
+
+def make_settings(tmp_path, model_provider="ollama", ollama_model="qwen3.5:9b", codex_model="gpt-5.4"):
+    return SimpleNamespace(
+        traderai_memory_path=str(tmp_path / "memory.sqlite3"),
+        model_provider=model_provider,
+        ollama_base_url="http://localhost:11434",
+        ollama_model=ollama_model,
+        ollama_num_ctx=64512,
+        openai_base_url="https://api.openai.com/v1",
+        openai_api_key=None,
+        openai_model="gpt-5.4-mini",
+        model_reasoning_effort="medium",
+        codex_command="codex",
+        codex_model=codex_model,
+        uex_base_url="https://api.uexcorp.space/2.0",
+        uex_secret_key=None,
+        uex_bearer_token=None,
+        traderai_user_name=None,
+        uex_notification_poll_seconds=60,
+        require_write_approval=True,
+        scmdb_base_url="https://scmdb.net",
+        cornerstone_base_url="https://finder.cstone.space",
+        scwiki_base_url="https://starcitizen.tools",
+        scwiki_api_base_url="https://api.star-citizen.wiki",
+    )

tests/test_tools.py

@@ -10,8 +10,10 @@ from traderai.uex_client import UEXClient
 class FakeUEX:
     def __init__(self):
         self.posts = []
+        self.get_calls = []
 
     async def get(self, path, params=None, authenticated=False):
+        self.get_calls.append({"path": path, "params": params, "authenticated": authenticated})
         if path == "commodities_prices_history":
             return {
                 "status": "ok",
@@ -80,6 +82,34 @@ class FakeUEX:
                     },
                 ],
             }
+        if path == "marketplace_trends":
+            return {
+                "status": "ok",
+                "data": [
+                    {
+                        "id_item": 2791,
+                        "item_name": "\"Quantanium\" Water Bottle",
+                        "item_slug": "quantanium-water-bottle",
+                        "currency": "UEC",
+                        "price_avg_sell": "937500",
+                        "price_avg_month_sell": "1072222",
+                        "price_min_sell": "750000",
+                        "price_max_sell": "1200000",
+                        "listings_count_sell": 4,
+                        "price_avg_buy": "500000",
+                        "price_avg_month_buy": "525000",
+                        "price_min_buy": "450000",
+                        "price_max_buy": "550000",
+                        "listings_count_buy": 2,
+                        "total_listings_count": 6,
+                        "negotiations_count": 18,
+                        "negotiations_open": 7,
+                        "negotiations_success": 9,
+                        "link_prices": "https://uexcorp.space/marketplace/home/?id_item=2791&mode=list",
+                        "link_prices_history": "https://uexcorp.space/marketplace/averages/?id_item=2791&quality_tier=q0&unit=unit",
+                    }
+                ],
+            }
         assert path == "marketplace_listings"
         return {
             "data": [
@@ -230,7 +260,10 @@ class FakeCornerstone:
             "url": f"{self.base_url}/ShipSalvageMods1/{item_id}",
             "html": """
                 <html>
-                  <head><title>Star Citizen - Salvage modifier - Abrade Scraper Module</title></head>
+                  <head>
+                    <title>Star Citizen - Salvage modifier - Abrade Scraper Module</title>
+                    <meta property="og:image" content="/images/abrade.png">
+                  </head>
                   <body>
                     <table>
                       <tr><td>NAME</td><td>Abrade Scraper Module</td></tr>
@@ -246,6 +279,94 @@ class FakeCornerstone:
             """,
         }
 
+    async def get_image_data(self, url, max_bytes=10_000_000):
+        assert url == f"{self.base_url}/images/abrade.png"
+        return {
+            "url": url,
+            "content_type": "image/png",
+            "size_bytes": 12,
+            "image_data": "ZmFrZS1pbWFnZQ==",
+        }
+
+
+class FakeSCWiki:
+    base_url = "https://starcitizen.tools"
+    api_base_url = "https://api.star-citizen.wiki"
+
+    async def search_pages(self, query, limit=5):
+        assert query == "Carrack"
+        return [
+            {
+                "pageid": 415,
+                "title": "Carrack",
+                "description": "Deep-space multi-crew explorer manufactured by Anvil Aerospace",
+                "extract": "The Anvil Carrack is a multi-crew explorer.",
+                "thumbnail": "https://media.starcitizen.tools/carrack.webp",
+                "url": "https://starcitizen.tools/Carrack",
+            }
+        ][:limit]
+
+    async def get_page_summary(self, title=None, pageid=None, chars=700):
+        assert title == "Carrack" or pageid == 415
+        return {
+            "pageid": 415,
+            "title": "Carrack",
+            "description": "Deep-space multi-crew explorer manufactured by Anvil Aerospace",
+            "extract": "The Anvil Carrack is a multi-crew explorer.",
+            "thumbnail": "https://media.starcitizen.tools/carrack.webp",
+            "url": "https://starcitizen.tools/Carrack",
+        }
+
+    async def search_verse(self, query):
+        assert query == "Carrack"
+        return [
+            {
+                "type": "vehicles",
+                "label": "Vehicles",
+                "results": [
+                    {
+                        "name": "Anvil Carrack",
+                        "class_name": "ANVL_Carrack",
+                        "extra_label": "Exploration",
+                        "web_url": "https://api.star-citizen.wiki/vehicles/anvl-carrack",
+                        "api_url": "https://api.star-citizen.wiki/api/vehicles/anvl-carrack",
+                    }
+                ],
+            }
+        ]
+
+    async def get_vehicle(self, slug):
+        assert slug == "anvl-carrack"
+        return {
+            "name": "Carrack",
+            "game_name": "Anvil Carrack",
+            "slug": "anvl-carrack",
+            "manufacturer": {"name": "Anvil Aerospace"},
+            "career": "Exploration",
+            "role": "Expedition",
+            "size_class": 5,
+            "cargo_capacity": 456,
+            "crew": {"min": 6, "max": 6},
+            "msrp": 600,
+            "pledge_url": "https://robertsspaceindustries.com/pledge/ships/carrack/Carrack",
+            "uex_prices": {
+                "purchase": [
+                    {
+                        "price_buy": 34398000,
+                        "terminal_name": "Astro Armada - Area 18",
+                        "starmap_location": {"name": "Area18", "parent_name": "ArcCorp", "star_system_name": "Stanton"},
+                        "game_version": "4.8.1-LIVE.11952564",
+                        "date_updated": "2026-05-20T18:39:37-04:00",
+                        "uex_link": "https://uexcorp.space/vehicles/home/list/in_game_sell/?id_terminal=148",
+                    }
+                ]
+            },
+            "description": {"en_EN": "The Anvil Carrack features reinforced fuel tanks for long-duration flight."},
+            "web_url": "https://api.star-citizen.wiki/vehicles/anvl-carrack",
+            "updated_at": "2026-06-08T00:34:00Z",
+            "version": "4.8.1-LIVE.11952564",
+        }
+
 
 @pytest.mark.asyncio
 async def test_search_marketplace_listings_filters_locally():
@@ -321,6 +442,65 @@ async def test_uex_get_projects_and_limits_results():
     assert result["items"] == [{"id": 10, "commodity_name": "Gold", "price_buy": 4120}]
 
 
+@pytest.mark.asyncio
+async def test_uex_get_marketplace_listings_accepts_item_and_operation_filters():
+    fake = FakeUEX()
+    registry = ToolRegistry(fake)
+
+    result = await registry.execute(
+        "get_uex_marketplace_listings",
+        {
+            "id_item": 2791,
+            "operation": "sell",
+            "fields": ["id", "slug", "operation"],
+        },
+    )
+
+    assert result["params"] == {"id_item": 2791, "operation": "sell"}
+    assert fake.get_calls[-1]["path"] == "marketplace_listings"
+    assert fake.get_calls[-1]["params"] == {"id_item": 2791, "operation": "sell"}
+
+
+@pytest.mark.asyncio
+async def test_get_marketplace_trends_returns_compact_wts_wtb_and_negotiation_metrics():
+    fake = FakeUEX()
+    registry = ToolRegistry(fake)
+
+    result = await registry.get_marketplace_trends(item_name="Quantanium", currency="UEC", quality_tier=0)
+
+    assert result["status"] == "ok"
+    assert result["count"] == 1
+    assert result["filters"] == {"item_name": "Quantanium", "currency": "UEC", "quality_tier": 0}
+    assert fake.get_calls[-1]["path"] == "marketplace_trends"
+    assert fake.get_calls[-1]["params"] == {"id_item": None, "item_name": "Quantanium", "item_slug": None, "id_category": None, "currency": "UEC", "quality_tier": 0}
+    assert result["trends"][0] == {
+        "id_item": 2791,
+        "item_name": "\"Quantanium\" Water Bottle",
+        "item_slug": "quantanium-water-bottle",
+        "currency": "UEC",
+        "sell": {
+            "avg_price": "937500",
+            "avg_price_month": "1072222",
+            "min_price": "750000",
+            "max_price": "1200000",
+            "listings_count": 4,
+        },
+        "buy": {
+            "avg_price": "500000",
+            "avg_price_month": "525000",
+            "min_price": "450000",
+            "max_price": "550000",
+            "listings_count": 2,
+        },
+        "total_listings_count": 6,
+        "negotiations_count": 18,
+        "negotiations_open": 7,
+        "negotiations_success": 9,
+        "link_prices": "https://uexcorp.space/marketplace/home/?id_item=2791&mode=list",
+        "link_prices_history": "https://uexcorp.space/marketplace/averages/?id_item=2791&quality_tier=q0&unit=unit",
+    }
+
+
 @pytest.mark.asyncio
 async def test_uex_api_catalog_exposes_resources_without_live_call():
     registry = ToolRegistry(FakeUEX())
@@ -356,6 +536,7 @@ def test_schemas_expose_specific_uex_tools_instead_of_generic_api_tool():
 
     assert "get_uex_commodities_prices" in names
     assert "get_uex_vehicles" in names
+    assert "get_marketplace_trends" in names
     assert "draft_uex_marketplace_advertise" in names
     assert "delete_uex_marketplace_listings" in names
     assert "uex_get" not in names
@@ -379,6 +560,19 @@ def test_schemas_expose_cornerstone_item_tools():
 
     assert "search_cornerstone_items" in names
     assert "get_cornerstone_item_locations" in names
+    assert "get_cornerstone_item_media" in names
+    assert "draft_marketplace_listing_with_cornerstone_image" in names
+
+
+def test_schemas_expose_scwiki_tools():
+    registry = ToolRegistry(FakeUEX(), scwiki=FakeSCWiki())
+
+    names = {schema["function"]["name"] for schema in registry.schemas}
+
+    assert "search_scwiki_pages" in names
+    assert "get_scwiki_page" in names
+    assert "search_scwiki_vehicles" in names
+    assert "get_scwiki_vehicle" in names
 
 
 @pytest.mark.asyncio
@@ -441,18 +635,127 @@ async def test_get_cornerstone_item_locations_parses_store_prices():
     ]
 
 
+@pytest.mark.asyncio
+async def test_get_cornerstone_item_media_returns_absolute_image_urls():
+    registry = ToolRegistry(FakeUEX(), cornerstone=FakeCornerstone())
+
+    result = await registry.get_cornerstone_item_media(query="abrade")
+
+    assert result["media"] == [
+        {
+            "url": "https://finder.cstone.test/images/abrade.png",
+            "source": "og:image",
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_search_scwiki_pages_returns_general_knowledge_matches():
+    registry = ToolRegistry(FakeUEX(), scwiki=FakeSCWiki())
+
+    result = await registry.search_scwiki_pages(query="Carrack")
+
+    assert result["source"] == "https://starcitizen.tools"
+    assert result["matched"] == 1
+    assert result["pages"][0]["title"] == "Carrack"
+    assert result["pages"][0]["url"] == "https://starcitizen.tools/Carrack"
+
+
+@pytest.mark.asyncio
+async def test_get_scwiki_vehicle_returns_ship_prices_and_store_context():
+    registry = ToolRegistry(FakeUEX(), scwiki=FakeSCWiki())
+
+    result = await registry.get_scwiki_vehicle(query="Carrack")
+
+    assert result["source"] == "https://api.star-citizen.wiki"
+    vehicle = result["vehicle"]
+    assert vehicle["name"] == "Carrack"
+    assert vehicle["manufacturer"] == "Anvil Aerospace"
+    assert vehicle["msrp"] == 600
+    assert vehicle["purchase_locations"] == [
+        {
+            "price_buy": 34398000,
+            "terminal_name": "Astro Armada - Area 18",
+            "location": "Area18",
+            "parent_location": "ArcCorp",
+            "star_system": "Stanton",
+            "game_version": "4.8.1-LIVE.11952564",
+            "date_updated": "2026-05-20T18:39:37-04:00",
+            "uex_link": "https://uexcorp.space/vehicles/home/list/in_game_sell/?id_terminal=148",
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_draft_marketplace_listing_with_cornerstone_image_adds_image_data_and_redacts_display():
+    registry = ToolRegistry(FakeUEX(), cornerstone=FakeCornerstone())
+
+    result = await registry.draft_marketplace_listing_with_cornerstone_image(
+        item_query="abrade",
+        id_category=3,
+        operation="sell",
+        type="item",
+        unit="unit",
+        title="Abrade Scraper Module",
+        description="Clean module, ready for pickup.",
+        price=21250,
+        currency="UEC",
+        language="en_US",
+        source="purchased_in_game",
+        in_stock=1,
+    )
+
+    pending = result["pending_action"]
+    stored = registry.pending_actions[pending["id"]]
+
+    assert pending["endpoint"] == "marketplace_advertise"
+    assert pending["payload"]["image_data"].startswith("<base64 image data redacted")
+    assert stored.payload["image_data"] == "ZmFrZS1pbWFnZQ=="
+    assert pending["metadata"]["cornerstone_image_status"] == "included"
+
+
+@pytest.mark.asyncio
+async def test_draft_marketplace_listing_can_reuse_pasted_chat_image():
+    registry = ToolRegistry(FakeUEX())
+
+    with registry.chat_image_scope([{"name": "listing.png", "content_type": "image/png", "image_data": "ZmFrZS1pbWFnZQ=="}]):
+        result = await registry.draft_marketplace_listing(
+            id_category=3,
+            operation="sell",
+            type="item",
+            unit="unit",
+            title="Abrade Scraper Module",
+            description="Clean module, ready for pickup.",
+            price=21250,
+            currency="UEC",
+            language="en_US",
+            use_attached_image=True,
+        )
+
+    pending = result["pending_action"]
+    stored = registry.pending_actions[pending["id"]]
+    assert pending["payload"]["image_data"].startswith("<base64 image data redacted")
+    assert stored.payload["image_data"] == "ZmFrZS1pbWFnZQ=="
+    assert pending["metadata"]["attached_chat_image_name"] == "listing.png"
+    assert pending["metadata"]["attached_chat_image_status"] == "included"
+
+
 def test_parse_cornerstone_item_page_extracts_locations():
     parsed = parse_cornerstone_item_page(
         """
-        <html><head><title>Star Citizen - Food - Whamburger</title></head>
+        <html><head><title>Star Citizen - Food - Whamburger</title><meta property="og:image" content="/img/wham.png"></head>
         <body><table><tr><td>NAME</td><td>Whamburger</td></tr></table>
+        <img src="https://example.test/extra.png" alt="Whamburger">
         <table><tr><th>LOCATION</th><th>BASE PRICE</th><th>VERIFIED</th></tr>
         <tr><td>Stanton - Area18 - Cubby Blast</td><td>9</td><td>2956-01-01</td></tr></table></body></html>
-        """
+        """,
+        "https://finder.cstone.test/Search/item-wham",
     )
 
     assert parsed["name"] == "Whamburger"
     assert parsed["locations"][0]["base_price"] == 9
+    assert parsed["media"][0]["url"] == "https://finder.cstone.test/img/wham.png"
+    assert parsed["media"][1]["url"] == "https://example.test/extra.png"
 
 
 @pytest.mark.asyncio

traderai/config.py

@@ -11,12 +11,21 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 CONFIG_FIELDS: dict[str, dict[str, Any]] = {
+    "model_provider": {"env": "MODEL_PROVIDER", "type": "string", "secret": False},
     "ollama_base_url": {"env": "OLLAMA_BASE_URL", "type": "string", "secret": False},
     "ollama_model": {"env": "OLLAMA_MODEL", "type": "string", "secret": False},
     "ollama_num_ctx": {"env": "OLLAMA_NUM_CTX", "type": "integer", "secret": False},
+    "openai_base_url": {"env": "OPENAI_BASE_URL", "type": "string", "secret": False},
+    "openai_model": {"env": "OPENAI_MODEL", "type": "string", "secret": False},
+    "model_reasoning_effort": {"env": "MODEL_REASONING_EFFORT", "type": "string", "secret": False},
+    "codex_command": {"env": "CODEX_COMMAND", "type": "string", "secret": False},
+    "codex_model": {"env": "CODEX_MODEL", "type": "string", "secret": False},
     "uex_base_url": {"env": "UEX_BASE_URL", "type": "string", "secret": False},
     "scmdb_base_url": {"env": "SCMDB_BASE_URL", "type": "string", "secret": False},
     "cornerstone_base_url": {"env": "CORNERSTONE_BASE_URL", "type": "string", "secret": False},
+    "scwiki_base_url": {"env": "SCWIKI_BASE_URL", "type": "string", "secret": False},
+    "scwiki_api_base_url": {"env": "SCWIKI_API_BASE_URL", "type": "string", "secret": False},
+    "openai_api_key": {"env": "OPENAI_API_KEY", "type": "string", "secret": True},
     "uex_secret_key": {"env": "UEX_SECRET_KEY", "type": "string", "secret": True},
     "uex_bearer_token": {"env": "UEX_BEARER_TOKEN", "type": "string", "secret": True},
     "traderai_user_name": {"env": "TRADERAI_USER_NAME", "type": "string", "secret": False},
@@ -62,12 +71,21 @@ class Settings(BaseSettings):
         env_file_encoding="utf-8",
     )
 
+    model_provider: str = "ollama"
     ollama_base_url: str = "http://localhost:11434"
     ollama_model: str = "qwen3.5:9b"
     ollama_num_ctx: int = 64512
+    openai_base_url: str = "https://api.openai.com/v1"
+    openai_model: str = "gpt-5.4-mini"
+    model_reasoning_effort: str = "medium"
+    codex_command: str = "codex"
+    codex_model: str = "gpt-5.4"
     uex_base_url: str = "https://api.uexcorp.space/2.0"
     scmdb_base_url: str = "https://scmdb.net"
     cornerstone_base_url: str = "https://finder.cstone.space"
+    scwiki_base_url: str = "https://starcitizen.tools"
+    scwiki_api_base_url: str = "https://api.star-citizen.wiki"
+    openai_api_key: str | None = Field(default=None)
     uex_secret_key: str | None = Field(default=None)
     uex_bearer_token: str | None = Field(default=None)
     traderai_user_name: str | None = Field(default=None)
@@ -75,11 +93,23 @@ class Settings(BaseSettings):
     uex_notification_poll_seconds: int = 60
     require_write_approval: bool = True
 
-    @field_validator("uex_secret_key", "uex_bearer_token", "traderai_user_name", mode="before")
+    @field_validator("openai_api_key", "uex_secret_key", "uex_bearer_token", "traderai_user_name", mode="before")
     @classmethod
     def _blank_optional(cls, value: Any) -> Any:
         return None if value == "" else value
 
+    @field_validator("model_provider", mode="before")
+    @classmethod
+    def _normalize_model_provider(cls, value: Any) -> str:
+        text = str(value or "ollama").strip().casefold()
+        return text if text in {"ollama", "openai", "codex"} else "ollama"
+
+    @field_validator("model_reasoning_effort", mode="before")
+    @classmethod
+    def _normalize_reasoning_effort(cls, value: Any) -> str:
+        text = str(value or "medium").strip().casefold()
+        return text if text in {"none", "minimal", "low", "medium", "high", "xhigh"} else "medium"
+
     @field_validator("traderai_memory_path", mode="before")
     @classmethod
     def _blank_memory_path(cls, value: Any) -> Any:
@@ -137,7 +167,7 @@ def save_settings(values: dict[str, Any]) -> dict[str, Any]:
 def _coerce_value(key: str, value: Any) -> Any:
     field_type = CONFIG_FIELDS[key]["type"]
     if value == "":
-        return None if key in {"uex_secret_key", "uex_bearer_token", "traderai_user_name"} else ""
+        return None if key in {"openai_api_key", "uex_secret_key", "uex_bearer_token", "traderai_user_name"} else ""
     if field_type == "integer":
         return int(value)
     if field_type == "boolean":

traderai/cornerstone_client.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 from html.parser import HTMLParser
+import base64
 import json
 from typing import Any
+from urllib.parse import urljoin
 
 import httpx
 
@@ -41,6 +43,23 @@ class CornerstoneClient:
             raise CornerstoneError(f"Cornerstone HTTP {response.status_code}: {response.text[:240]}")
         return {"url": str(response.url), "html": response.text}
 
+    async def get_image_data(self, url: str, max_bytes: int = 10_000_000) -> dict[str, Any]:
+        async with httpx.AsyncClient(timeout=30, follow_redirects=True) as client:
+            response = await client.get(url, headers={"Accept": "image/png,image/jpeg,image/*"})
+        if response.status_code >= 400:
+            raise CornerstoneError(f"Cornerstone image HTTP {response.status_code}: {response.text[:240]}")
+        content_type = response.headers.get("content-type", "").split(";")[0].strip().casefold()
+        if content_type not in {"image/jpeg", "image/jpg", "image/png"}:
+            raise CornerstoneError(f"Cornerstone image was not JPG or PNG: {content_type or 'unknown content type'}")
+        if len(response.content) > max_bytes:
+            raise CornerstoneError(f"Cornerstone image is larger than {max_bytes} bytes.")
+        return {
+            "url": str(response.url),
+            "content_type": content_type,
+            "size_bytes": len(response.content),
+            "image_data": base64.b64encode(response.content).decode("ascii"),
+        }
+
     async def _get_json(self, path: str) -> Any:
         async with httpx.AsyncClient(timeout=30, follow_redirects=True) as client:
             response = await client.get(f"{self.base_url}/{path.lstrip('/')}", headers={"Accept": "application/json"})
@@ -58,6 +77,7 @@ class CornerstonePageParser(HTMLParser):
         super().__init__(convert_charrefs=True)
         self.title = ""
         self.tables: list[list[list[str]]] = []
+        self.images: list[dict[str, str]] = []
         self._skip_depth = 0
         self._in_title = False
         self._current_table: list[list[str]] | None = None
@@ -73,6 +93,29 @@ class CornerstonePageParser(HTMLParser):
             return
         if tag == "title":
             self._in_title = True
+        elif tag == "meta":
+            attr_map = self._attrs(attrs)
+            name = (attr_map.get("property") or attr_map.get("name") or "").casefold()
+            content = attr_map.get("content") or ""
+            if content and name in {"og:image", "twitter:image", "twitter:image:src"}:
+                self.images.append({"url": content, "source": name})
+        elif tag == "link":
+            attr_map = self._attrs(attrs)
+            rel = (attr_map.get("rel") or "").casefold()
+            href = attr_map.get("href") or ""
+            if href and "image_src" in rel:
+                self.images.append({"url": href, "source": "link:image_src"})
+        elif tag == "img":
+            attr_map = self._attrs(attrs)
+            url = attr_map.get("src") or attr_map.get("data-src") or attr_map.get("data-original") or ""
+            if url:
+                self.images.append(
+                    {
+                        "url": url,
+                        "alt": attr_map.get("alt") or "",
+                        "source": "img",
+                    }
+                )
         elif tag == "table":
             self._current_table = []
         elif tag == "tr" and self._current_table is not None:
@@ -110,8 +153,12 @@ class CornerstonePageParser(HTMLParser):
         if self._current_cell is not None:
             self._current_cell.append(data)
 
+    @staticmethod
+    def _attrs(attrs: list[tuple[str, str | None]]) -> dict[str, str]:
+        return {key.casefold(): value or "" for key, value in attrs}
 
-def parse_cornerstone_item_page(html: str) -> dict[str, Any]:
+
+def parse_cornerstone_item_page(html: str, page_url: str | None = None) -> dict[str, Any]:
     parser = CornerstonePageParser()
     parser.feed(html)
     info: dict[str, Any] = {"page_title": " ".join(parser.title.split())}
@@ -142,6 +189,9 @@ def parse_cornerstone_item_page(html: str) -> dict[str, Any]:
                     general[key] = value
 
     info["name"] = general.get("name") or _name_from_title(info["page_title"])
+    media = _dedupe_media(parser.images, page_url)
+    if media:
+        info["media"] = media
     if general:
         info["general"] = general
     info["locations"] = locations
@@ -157,3 +207,20 @@ def _name_from_title(title: str) -> str | None:
     if " - " not in title:
         return title or None
     return title.rsplit(" - ", 1)[-1].strip() or None
+
+
+def _dedupe_media(images: list[dict[str, str]], page_url: str | None = None) -> list[dict[str, str]]:
+    media = []
+    seen = set()
+    for image in images:
+        raw_url = (image.get("url") or "").strip()
+        if not raw_url or raw_url.startswith("data:"):
+            continue
+        url = urljoin(page_url or "", raw_url)
+        if url in seen:
+            continue
+        seen.add(url)
+        item = dict(image)
+        item["url"] = url
+        media.append(item)
+    return media

traderai/desktop.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import os
 from pathlib import Path
 import shutil
@@ -25,6 +26,10 @@ def resource_path(*parts: str) -> Path:
 def main() -> None:
     try:
         _chdir_to_app_dir()
+        backend_port = _backend_port_from_args()
+        if backend_port is not None:
+            _run_server(backend_port)
+            return
         _log("TraderAI desktop starting")
         _log(f"cwd={Path.cwd()}")
         _log(f"executable={sys.executable}")
@@ -36,9 +41,13 @@ def main() -> None:
             _log("existing TraderAI backend found; opening window")
             _open_window(url)
             return
-        server_thread = threading.Thread(target=_run_server, args=(port,), daemon=True)
+        if getattr(sys, "frozen", False):
-        server_thread.start()
+            backend_process = _start_backend_process(port)
-        _log("backend thread started")
+            _log(f"backend process started pid={backend_process.pid}")
+        else:
+            server_thread = threading.Thread(target=_run_server, args=(port,), daemon=True)
+            server_thread.start()
+            _log("backend thread started")
         _wait_for_server(url)
         _log("backend health check passed")
         _open_window(url)
@@ -62,6 +71,22 @@ def _select_port() -> int:
     return _free_port()
 
 
+def _backend_port_from_args() -> int | None:
+    args = sys.argv[1:]
+    if len(args) >= 2 and args[0] == "--backend-port":
+        return int(args[1])
+    return None
+
+
+def _start_backend_process(port: int) -> subprocess.Popen:
+    command = [sys.executable, "--backend-port", str(port)]
+    _log(f"starting backend subprocess: {' '.join(command)}")
+    kwargs: dict[str, object] = {}
+    if sys.platform == "win32":
+        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+    return subprocess.Popen(command, **kwargs)
+
+
 def _port_available(port: int) -> bool:
     try:
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
@@ -88,6 +113,9 @@ def _existing_server_ready(url: str) -> bool:
 def _run_server(port: int) -> NoReturn:
     try:
         _log(f"backend starting on port {port}")
+        if sys.platform == "win32" and hasattr(asyncio, "WindowsProactorEventLoopPolicy"):
+            asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+            _log("set Windows Proactor event loop policy for subprocess-compatible backend")
         from traderai.server import app
 
         config = uvicorn.Config(

traderai/plans.py

@@ -0,0 +1,601 @@
+from __future__ import annotations
+
+import json
+import uuid
+from typing import Any
+
+from traderai.memory import MemoryStore, iso_now
+
+
+DEFAULT_PLAN_CADENCE = "0 */6 * * *"
+
+
+class ContinualPlanStore:
+    def __init__(self, memory: MemoryStore) -> None:
+        self.memory = memory
+        self._init_db()
+
+    def _init_db(self) -> None:
+        with self.memory._connect() as db:
+            db.executescript(
+                """
+                CREATE TABLE IF NOT EXISTS continual_plans (
+                    id TEXT PRIMARY KEY,
+                    title TEXT NOT NULL,
+                    kind TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    objective TEXT NOT NULL,
+                    constraints TEXT NOT NULL DEFAULT '{}',
+                    cadence TEXT NOT NULL,
+                    next_run_at TEXT,
+                    last_run_at TEXT,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS continual_plan_items (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    plan_id TEXT NOT NULL,
+                    item_name TEXT NOT NULL,
+                    desired_quantity INTEGER NOT NULL DEFAULT 1,
+                    max_unit_price REAL,
+                    status TEXT NOT NULL DEFAULT 'active',
+                    acquired_quantity INTEGER NOT NULL DEFAULT 0,
+                    metadata TEXT NOT NULL DEFAULT '{}',
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS continual_plan_candidates (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    plan_id TEXT NOT NULL,
+                    plan_item_id INTEGER NOT NULL,
+                    listing_id TEXT,
+                    listing_slug TEXT,
+                    title TEXT,
+                    seller TEXT,
+                    price REAL,
+                    currency TEXT,
+                    stock INTEGER,
+                    location TEXT,
+                    score REAL,
+                    first_seen_at TEXT NOT NULL,
+                    last_seen_at TEXT NOT NULL,
+                    status TEXT NOT NULL DEFAULT 'current',
+                    metadata TEXT NOT NULL DEFAULT '{}',
+                    UNIQUE(plan_item_id, listing_id)
+                );
+
+                CREATE TABLE IF NOT EXISTS continual_plan_events (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    plan_id TEXT NOT NULL,
+                    kind TEXT NOT NULL,
+                    message TEXT NOT NULL,
+                    metadata TEXT NOT NULL DEFAULT '{}',
+                    created_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS continual_plan_negotiations (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    plan_id TEXT NOT NULL,
+                    plan_item_id INTEGER,
+                    candidate_id INTEGER,
+                    listing_id TEXT,
+                    listing_slug TEXT,
+                    negotiation_id TEXT,
+                    negotiation_hash TEXT,
+                    status TEXT NOT NULL DEFAULT 'drafted',
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+                """
+            )
+
+    def create_plan(
+        self,
+        title: str,
+        kind: str = "buying",
+        objective: str = "",
+        items: list[dict[str, Any]] | None = None,
+        constraints: dict[str, Any] | None = None,
+        cadence: str | None = None,
+        status: str | None = None,
+    ) -> dict[str, Any]:
+        clean_items = [item for item in (items or []) if str(item.get("item_name") or item.get("name") or "").strip()]
+        plan_id = f"plan-{uuid.uuid4()}"
+        now = iso_now()
+        clean_kind = (kind.strip() or "buying").casefold()
+        resolved_status = status or ("needs_input" if clean_kind == "buying" and not clean_items else "active")
+        with self.memory._connect() as db:
+            db.execute(
+                """
+                INSERT INTO continual_plans(id, title, kind, status, objective, constraints, cadence, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    plan_id,
+                    title.strip() or "Continual plan",
+                    clean_kind,
+                    resolved_status,
+                    objective.strip() or title.strip(),
+                    json.dumps(constraints or {}),
+                    (cadence or DEFAULT_PLAN_CADENCE).strip() or DEFAULT_PLAN_CADENCE,
+                    now,
+                    now,
+                ),
+            )
+            for item in clean_items:
+                db.execute(
+                    """
+                    INSERT INTO continual_plan_items(
+                        plan_id, item_name, desired_quantity, max_unit_price, status,
+                        acquired_quantity, metadata, created_at, updated_at
+                    )
+                    VALUES (?, ?, ?, ?, 'active', ?, ?, ?, ?)
+                    """,
+                    (
+                        plan_id,
+                        str(item.get("item_name") or item.get("name")).strip(),
+                        max(1, int(item.get("desired_quantity") or item.get("quantity") or 1)),
+                        item.get("max_unit_price"),
+                        max(0, int(item.get("acquired_quantity") or 0)),
+                        json.dumps(item.get("metadata") or {}),
+                        now,
+                        now,
+                    ),
+                )
+        if clean_kind == "buying" and not clean_items:
+            self.add_event(plan_id, "needs_input", "Created plan, but no item checklist was provided. Add the required parts before it can run.")
+        elif clean_items:
+            self.add_event(plan_id, "created", f"Created continual {clean_kind} plan with {len(clean_items)} checklist item(s).")
+        else:
+            self.add_event(plan_id, "created", f"Created continual {clean_kind} plan.")
+        return self.get_plan(plan_id) or {}
+
+    def list_plans(self, include_inactive: bool = True) -> list[dict[str, Any]]:
+        where = "" if include_inactive else "WHERE status = 'active'"
+        with self.memory._connect() as db:
+            rows = db.execute(
+                f"""
+                SELECT *
+                FROM continual_plans
+                {where}
+                ORDER BY
+                    CASE status WHEN 'active' THEN 0 WHEN 'needs_input' THEN 1 WHEN 'paused' THEN 2 ELSE 3 END,
+                    updated_at DESC
+                """
+            ).fetchall()
+        return [self._plan_row(row) for row in rows]
+
+    def get_plan(self, plan_id: str) -> dict[str, Any] | None:
+        with self.memory._connect() as db:
+            plan = db.execute("SELECT * FROM continual_plans WHERE id = ?", (plan_id,)).fetchone()
+        if not plan:
+            return None
+        data = self._plan_row(plan)
+        data["items"] = self.list_items(plan_id)
+        data["candidates"] = self.list_candidates(plan_id)
+        data["negotiations"] = self.list_negotiations(plan_id)
+        data["events"] = self.list_events(plan_id)
+        return data
+
+    def list_items(self, plan_id: str) -> list[dict[str, Any]]:
+        with self.memory._connect() as db:
+            rows = db.execute(
+                "SELECT * FROM continual_plan_items WHERE plan_id = ? ORDER BY id",
+                (plan_id,),
+            ).fetchall()
+        return [self._json_row(row, "metadata") for row in rows]
+
+    def list_candidates(self, plan_id: str, limit: int = 100) -> list[dict[str, Any]]:
+        with self.memory._connect() as db:
+            rows = db.execute(
+                """
+                SELECT *
+                FROM continual_plan_candidates
+                WHERE plan_id = ?
+                ORDER BY status = 'current' DESC, score DESC, last_seen_at DESC
+                LIMIT ?
+                """,
+                (plan_id, limit),
+            ).fetchall()
+        return [self._json_row(row, "metadata") for row in rows]
+
+    def list_events(self, plan_id: str, limit: int = 50) -> list[dict[str, Any]]:
+        with self.memory._connect() as db:
+            rows = db.execute(
+                """
+                SELECT *
+                FROM continual_plan_events
+                WHERE plan_id = ?
+                ORDER BY id DESC
+                LIMIT ?
+                """,
+                (plan_id, limit),
+            ).fetchall()
+        return [self._json_row(row, "metadata") for row in rows]
+
+    def list_negotiations(self, plan_id: str) -> list[dict[str, Any]]:
+        with self.memory._connect() as db:
+            rows = db.execute(
+                "SELECT * FROM continual_plan_negotiations WHERE plan_id = ? ORDER BY updated_at DESC",
+                (plan_id,),
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def set_status(self, plan_id: str, status: str) -> dict[str, Any] | None:
+        with self.memory._connect() as db:
+            db.execute(
+                "UPDATE continual_plans SET status = ?, updated_at = ? WHERE id = ?",
+                (status, iso_now(), plan_id),
+            )
+        self.add_event(plan_id, status, f"Plan status changed to {status}.")
+        return self.get_plan(plan_id)
+
+    def delete_plan(self, plan_id: str) -> bool:
+        with self.memory._connect() as db:
+            deleted = db.execute("DELETE FROM continual_plans WHERE id = ?", (plan_id,)).rowcount
+            if not deleted:
+                return False
+            db.execute("DELETE FROM continual_plan_items WHERE plan_id = ?", (plan_id,))
+            db.execute("DELETE FROM continual_plan_candidates WHERE plan_id = ?", (plan_id,))
+            db.execute("DELETE FROM continual_plan_events WHERE plan_id = ?", (plan_id,))
+            db.execute("DELETE FROM continual_plan_negotiations WHERE plan_id = ?", (plan_id,))
+        return True
+
+    def add_event(self, plan_id: str, kind: str, message: str, metadata: dict[str, Any] | None = None) -> dict[str, Any]:
+        now = iso_now()
+        with self.memory._connect() as db:
+            cursor = db.execute(
+                """
+                INSERT INTO continual_plan_events(plan_id, kind, message, metadata, created_at)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                (plan_id, kind, message, json.dumps(metadata or {}), now),
+            )
+        return {"id": cursor.lastrowid, "plan_id": plan_id, "kind": kind, "message": message, "created_at": now}
+
+    def update_schedule(self, plan_id: str, next_run_at: str | None = None, last_run_at: str | None = None) -> None:
+        fields = ["next_run_at = ?", "updated_at = ?"]
+        values: list[Any] = [next_run_at, iso_now()]
+        if last_run_at is not None:
+            fields.insert(1, "last_run_at = ?")
+            values.insert(1, last_run_at)
+        values.append(plan_id)
+        with self.memory._connect() as db:
+            db.execute(f"UPDATE continual_plans SET {', '.join(fields)} WHERE id = ?", values)
+
+    def upsert_candidate(self, plan_id: str, plan_item_id: int, listing: dict[str, Any], score: float) -> dict[str, Any]:
+        now = iso_now()
+        listing_id = str(listing.get("id") or listing.get("listing_id") or listing.get("slug") or uuid.uuid4())
+        metadata = dict(listing)
+        with self.memory._connect() as db:
+            db.execute(
+                """
+                INSERT INTO continual_plan_candidates(
+                    plan_id, plan_item_id, listing_id, listing_slug, title, seller, price, currency,
+                    stock, location, score, first_seen_at, last_seen_at, status, metadata
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'current', ?)
+                ON CONFLICT(plan_item_id, listing_id) DO UPDATE SET
+                    listing_slug=excluded.listing_slug,
+                    title=excluded.title,
+                    seller=excluded.seller,
+                    price=excluded.price,
+                    currency=excluded.currency,
+                    stock=excluded.stock,
+                    location=excluded.location,
+                    score=excluded.score,
+                    last_seen_at=excluded.last_seen_at,
+                    status='current',
+                    metadata=excluded.metadata
+                """,
+                (
+                    plan_id,
+                    plan_item_id,
+                    listing_id,
+                    listing.get("slug"),
+                    listing.get("title"),
+                    listing.get("advertiser") or listing.get("user_username") or listing.get("seller"),
+                    listing.get("price"),
+                    listing.get("currency"),
+                    listing.get("in_stock") or listing.get("stock"),
+                    listing.get("location"),
+                    score,
+                    now,
+                    now,
+                    json.dumps(metadata),
+                ),
+            )
+            row = db.execute(
+                "SELECT * FROM continual_plan_candidates WHERE plan_item_id = ? AND listing_id = ?",
+                (plan_item_id, listing_id),
+            ).fetchone()
+        return self._json_row(row, "metadata")
+
+    def mark_stale_candidates(self, plan_item_id: int, seen_listing_ids: set[str]) -> int:
+        with self.memory._connect() as db:
+            rows = db.execute(
+                "SELECT id, listing_id FROM continual_plan_candidates WHERE plan_item_id = ? AND status = 'current'",
+                (plan_item_id,),
+            ).fetchall()
+            stale_ids = [row["id"] for row in rows if str(row["listing_id"]) not in seen_listing_ids]
+            if stale_ids:
+                placeholders = ",".join("?" for _ in stale_ids)
+                db.execute(
+                    f"UPDATE continual_plan_candidates SET status = 'stale', last_seen_at = ? WHERE id IN ({placeholders})",
+                    (iso_now(), *stale_ids),
+                )
+        return len(stale_ids)
+
+    def mark_candidate_drafted(self, candidate_id: int) -> None:
+        with self.memory._connect() as db:
+            db.execute("UPDATE continual_plan_candidates SET status = 'drafted', last_seen_at = ? WHERE id = ?", (iso_now(), candidate_id))
+
+    def add_negotiation(self, plan_id: str, plan_item_id: int | None, candidate_id: int | None, metadata: dict[str, Any]) -> dict[str, Any]:
+        now = iso_now()
+        with self.memory._connect() as db:
+            cursor = db.execute(
+                """
+                INSERT INTO continual_plan_negotiations(
+                    plan_id, plan_item_id, candidate_id, listing_id, listing_slug,
+                    negotiation_id, negotiation_hash, status, created_at, updated_at
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    plan_id,
+                    plan_item_id,
+                    candidate_id,
+                    metadata.get("listing_id"),
+                    metadata.get("listing_slug"),
+                    metadata.get("id_negotiation"),
+                    metadata.get("hash"),
+                    metadata.get("status") or "drafted",
+                    now,
+                    now,
+                ),
+            )
+            row = db.execute("SELECT * FROM continual_plan_negotiations WHERE id = ?", (cursor.lastrowid,)).fetchone()
+        return dict(row)
+
+    def has_negotiation_for_candidate(self, plan_id: str, plan_item_id: int, candidate: dict[str, Any]) -> bool:
+        with self.memory._connect() as db:
+            row = db.execute(
+                """
+                SELECT id
+                FROM continual_plan_negotiations
+                WHERE plan_id = ?
+                  AND plan_item_id = ?
+                  AND (
+                    candidate_id = ?
+                    OR (listing_id IS NOT NULL AND listing_id = ?)
+                    OR (listing_slug IS NOT NULL AND listing_slug = ?)
+                  )
+                LIMIT 1
+                """,
+                (
+                    plan_id,
+                    plan_item_id,
+                    candidate.get("id"),
+                    candidate.get("listing_id"),
+                    candidate.get("listing_slug"),
+                ),
+            ).fetchone()
+        return row is not None
+
+    @staticmethod
+    def _json_row(row: Any, *json_fields: str) -> dict[str, Any]:
+        data = dict(row)
+        for field in json_fields:
+            try:
+                data[field] = json.loads(data.get(field) or "{}")
+            except (TypeError, json.JSONDecodeError):
+                data[field] = {}
+        return data
+
+    @classmethod
+    def _plan_row(cls, row: Any) -> dict[str, Any]:
+        return cls._json_row(row, "constraints")
+
+
+class ContinualPlanRunner:
+    def __init__(self, store: ContinualPlanStore, tools: Any, memory: MemoryStore, agent: Any | None = None) -> None:
+        self.store = store
+        self.tools = tools
+        self.memory = memory
+        self.agent = agent
+
+    def bind_agent(self, agent: Any) -> None:
+        self.agent = agent
+
+    async def run_plan(self, plan_id: str) -> dict[str, Any]:
+        plan = self.store.get_plan(plan_id)
+        if not plan:
+            return {"error": f"Plan not found: {plan_id}"}
+        if plan["status"] != "active":
+            message = f"Skipped {plan['title']} because status is {plan['status']}."
+            self.store.add_event(plan_id, "skipped", message)
+            return {"status": "skipped", "summary": message, "plan": self.store.get_plan(plan_id)}
+        try:
+            if plan["kind"] == "buying":
+                result = await self._run_buying_plan(plan)
+            else:
+                result = await self._run_agent_plan(plan)
+            self.store.update_schedule(plan_id, plan.get("next_run_at"), last_run_at=iso_now())
+            self.memory.add_outbox(result["summary"])
+            return {**result, "plan": self.store.get_plan(plan_id)}
+        except Exception as exc:
+            message = f"Continual plan failed: {exc}"
+            self.store.add_event(plan_id, "error", message)
+            self.memory.add_outbox(f"{plan['title']}: {message}")
+            self.store.update_schedule(plan_id, plan.get("next_run_at"), last_run_at=iso_now())
+            return {"error": str(exc), "summary": message, "plan": self.store.get_plan(plan_id)}
+
+    async def _run_agent_plan(self, plan: dict[str, Any]) -> dict[str, Any]:
+        if self.agent is None:
+            raise RuntimeError("No agent is bound to run generic continual plans.")
+        prompt = self._agent_plan_prompt(plan)
+        response = await self.agent.generate_wake_response(prompt)
+        summary = f"{plan['title']}: {response}"
+        self.store.add_event(plan["id"], "run", "Ran generic continual plan through the agent.", {"response": response})
+        return {"status": "ok", "summary": summary, "checked": 0, "drafted": 0}
+
+    async def _run_buying_plan(self, plan: dict[str, Any]) -> dict[str, Any]:
+        items = [item for item in plan.get("items") or [] if item.get("status") != "acquired"]
+        if not items:
+            self.store.set_status(plan["id"], "completed")
+            summary = f"{plan['title']}: all checklist items are marked acquired."
+            return {"status": "completed", "summary": summary, "drafted": 0, "checked": 0}
+
+        checked = 0
+        drafted = 0
+        best_lines = []
+        constraints = plan.get("constraints") or {}
+        excluded_sellers = {str(value).casefold() for value in constraints.get("excluded_sellers") or []}
+        preferred_locations = [str(value).casefold() for value in constraints.get("preferred_locations") or []]
+
+        for item in items:
+            response = await self.tools.search_marketplace_listings(
+                query=item["item_name"],
+                operation="sell",
+                type="item",
+                limit=25,
+            )
+            listings = response.get("listings") or response.get("data") or []
+            seen: set[str] = set()
+            candidates = []
+            for listing in listings:
+                if not isinstance(listing, dict):
+                    continue
+                listing_id = str(listing.get("id") or listing.get("slug") or "")
+                if listing_id:
+                    seen.add(listing_id)
+                if str(listing.get("advertiser") or listing.get("seller") or "").casefold() in excluded_sellers:
+                    continue
+                score = self._candidate_score(listing, item, preferred_locations)
+                candidate = self.store.upsert_candidate(plan["id"], int(item["id"]), listing, score)
+                candidates.append(candidate)
+            stale = self.store.mark_stale_candidates(int(item["id"]), seen)
+            checked += 1
+            current_candidates = [candidate for candidate in candidates if candidate.get("status") == "current"]
+            current_candidates.sort(key=lambda candidate: (-float(candidate.get("score") or 0), float(candidate.get("price") or 10**18)))
+            best = current_candidates[0] if current_candidates else None
+            if not best:
+                best_lines.append(f"{item['item_name']}: no active matching sell listings found.")
+                self.store.add_event(plan["id"], "search", f"{item['item_name']}: no active candidates found.", {"stale": stale})
+                continue
+
+            best_lines.append(
+                f"{item['item_name']}: best candidate is {best.get('title') or best.get('listing_slug')} "
+                f"at {self._format_price(best.get('price'), best.get('currency'))} from {best.get('seller') or 'unknown seller'}."
+            )
+            self.store.add_event(
+                plan["id"],
+                "search",
+                f"{item['item_name']}: found {len(current_candidates)} current candidate(s); {stale} stale candidate(s) marked.",
+                {"best_candidate_id": best.get("id")},
+            )
+
+            if self.store.has_negotiation_for_candidate(plan["id"], int(item["id"]), best) or not self._within_budget(best, item, constraints):
+                continue
+            draft = await self._draft_buying_message(plan, item, best)
+            if "pending_action" in draft:
+                drafted += 1
+                self.store.mark_candidate_drafted(int(best["id"]))
+                self.store.add_negotiation(
+                    plan["id"],
+                    int(item["id"]),
+                    int(best["id"]),
+                    {
+                        "listing_id": best.get("listing_id"),
+                        "listing_slug": best.get("listing_slug"),
+                        "status": "drafted",
+                    },
+                )
+                self.store.add_event(
+                    plan["id"],
+                    "draft",
+                    f"Drafted negotiation opener for {item['item_name']} candidate {best.get('listing_id')}.",
+                    {"pending_action_id": draft["pending_action"].get("id"), "candidate_id": best.get("id")},
+                )
+
+        summary = f"{plan['title']}: checked {checked} item(s). " + " ".join(best_lines[:4])
+        if drafted:
+            summary += f" Drafted {drafted} negotiation message(s) for approval."
+        self.store.add_event(plan["id"], "run", summary, {"checked": checked, "drafted": drafted})
+        return {"status": "ok", "summary": summary, "checked": checked, "drafted": drafted}
+
+    async def _draft_buying_message(self, plan: dict[str, Any], item: dict[str, Any], candidate: dict[str, Any]) -> dict[str, Any]:
+        tone = (plan.get("constraints") or {}).get("message_tone") or "polite and concise"
+        message = (
+            f"Hi, I am interested in your {candidate.get('title') or item['item_name']} listing "
+            f"for {self._format_price(candidate.get('price'), candidate.get('currency'))}. "
+            f"Is it still available? I am trying to complete: {plan['objective']}. "
+            f"Tone note: {tone}."
+        )
+        return await self.tools.draft_negotiation_message(
+            message=message,
+            id_listing=self._int_or_none(candidate.get("listing_id")),
+            plan_id=plan["id"],
+            plan_item_id=int(item["id"]),
+            candidate_id=int(candidate["id"]),
+            listing_slug=candidate.get("listing_slug"),
+        )
+
+    @staticmethod
+    def _candidate_score(listing: dict[str, Any], item: dict[str, Any], preferred_locations: list[str]) -> float:
+        price = float(listing.get("price") or 10**12)
+        max_price = item.get("max_unit_price")
+        budget_bonus = 40.0 if max_price and price <= float(max_price) else 0.0
+        stock = float(listing.get("in_stock") or listing.get("stock") or 1)
+        location = str(listing.get("location") or "").casefold()
+        location_bonus = 8.0 if preferred_locations and any(place in location for place in preferred_locations) else 0.0
+        return round(max(0.0, 50.0 - (price / 10_000_000.0)) + min(stock, 20.0) + budget_bonus + location_bonus, 4)
+
+    @staticmethod
+    def _within_budget(candidate: dict[str, Any], item: dict[str, Any], constraints: dict[str, Any]) -> bool:
+        price = candidate.get("price")
+        if price is None:
+            return False
+        max_price = item.get("max_unit_price") or constraints.get("max_unit_price")
+        return max_price is None or float(price) <= float(max_price)
+
+    @staticmethod
+    def _format_price(price: Any, currency: Any) -> str:
+        if isinstance(price, (int, float)):
+            return f"{price:,.0f} {currency or 'UEC'}"
+        return f"unknown price {currency or 'UEC'}"
+
+    @staticmethod
+    def _int_or_none(value: Any) -> int | None:
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return None
+
+    @staticmethod
+    def _agent_plan_prompt(plan: dict[str, Any]) -> str:
+        recent_events = [
+            {
+                "kind": event.get("kind"),
+                "message": event.get("message"),
+                "created_at": event.get("created_at"),
+            }
+            for event in (plan.get("events") or [])[:8]
+        ]
+        payload = {
+            "plan_id": plan.get("id"),
+            "title": plan.get("title"),
+            "kind": plan.get("kind"),
+            "objective": plan.get("objective"),
+            "constraints": plan.get("constraints") or {},
+            "items": plan.get("items") or [],
+            "recent_events": recent_events,
+        }
+        return (
+            "Continual plan wake run. Continue this durable plan and write an Inbox-ready summary. "
+            "Use tools as needed. For any account-affecting marketplace write, only draft a pending action for approval. "
+            "Do not claim a message, offer, listing, or negotiation was sent unless an approved action result says it was sent. "
+            f"Plan JSON: {json.dumps(payload, ensure_ascii=True)}"
+        )

traderai/scheduler.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime
+from datetime import datetime, timedelta
 from typing import Any
 from uuid import uuid4
 
@@ -10,7 +10,7 @@ from apscheduler.triggers.date import DateTrigger
 from apscheduler.triggers.interval import IntervalTrigger
 from tzlocal import get_localzone
 
-from traderai.memory import MemoryStore, iso_now, time_since
+from traderai.memory import MemoryStore, iso_now, parse_iso, time_since, utc_now
 
 
 UEX_NOTIFICATION_JOB_ID = "uex-notification-poll"
@@ -22,11 +22,15 @@ class WakeScheduler:
         self.scheduler = AsyncIOScheduler(timezone=get_localzone())
         self.agent = None
         self.uex = None
+        self.plan_runner = None
         self.notification_poll_seconds = 60
 
     def bind_agent(self, agent: Any) -> None:
         self.agent = agent
 
+    def bind_plan_runner(self, plan_runner: Any) -> None:
+        self.plan_runner = plan_runner
+
     def bind_uex_notifications(self, uex: Any, poll_seconds: int = 60) -> None:
         self.uex = uex
         self.notification_poll_seconds = max(15, poll_seconds)
@@ -37,6 +41,9 @@ class WakeScheduler:
         self._schedule_notification_poll()
         for job in self.memory.list_jobs():
             self._schedule_existing(job)
+        if self.plan_runner is not None:
+            for plan in self.plan_runner.store.list_plans(include_inactive=False):
+                self.schedule_plan(plan)
 
     def shutdown(self) -> None:
         if self.scheduler.running:
@@ -59,6 +66,70 @@ class WakeScheduler:
     def list_jobs(self) -> list[dict[str, Any]]:
         return self.memory.list_jobs()
 
+    def schedule_plan(self, plan: dict[str, Any]) -> dict[str, Any]:
+        if self.plan_runner is None or plan.get("status") != "active":
+            return plan
+        job_id = self._plan_job_id(plan["id"])
+        previous_next_run = plan.get("next_run_at")
+        trigger = CronTrigger.from_crontab(plan.get("cadence") or "0 */6 * * *")
+        self.scheduler.add_job(self._run_plan, trigger=trigger, id=job_id, args=[plan["id"]], replace_existing=True)
+        job = self.scheduler.get_job(job_id)
+        next_run = job.next_run_time if job else None
+        self.plan_runner.store.update_schedule(plan["id"], next_run.isoformat() if next_run else None)
+        if self._plan_is_overdue(previous_next_run):
+            catchup_id = self._plan_catchup_job_id(plan["id"])
+            self.scheduler.add_job(
+                self._run_plan,
+                trigger=DateTrigger(run_date=datetime.now() + timedelta(seconds=5)),
+                id=catchup_id,
+                args=[plan["id"]],
+                replace_existing=True,
+            )
+            self.plan_runner.store.add_event(
+                plan["id"],
+                "catchup_scheduled",
+                "Plan was overdue while the app was closed, so a one-time catch-up run was scheduled after startup.",
+                {"previous_next_run_at": previous_next_run},
+            )
+        return self.plan_runner.store.get_plan(plan["id"]) or plan
+
+    def unschedule_plan(self, plan_id: str) -> None:
+        job_id = self._plan_job_id(plan_id)
+        if self.scheduler.get_job(job_id):
+            self.scheduler.remove_job(job_id)
+        catchup_id = self._plan_catchup_job_id(plan_id)
+        if self.scheduler.get_job(catchup_id):
+            self.scheduler.remove_job(catchup_id)
+        if self.plan_runner is not None:
+            self.plan_runner.store.update_schedule(plan_id, None)
+
+    async def _run_plan(self, plan_id: str) -> None:
+        if self.plan_runner is None:
+            return
+        result = await self.plan_runner.run_plan(plan_id)
+        plan = result.get("plan") or self.plan_runner.store.get_plan(plan_id)
+        if plan and plan.get("status") == "active":
+            job = self.scheduler.get_job(self._plan_job_id(plan_id))
+            next_run = job.next_run_time if job else None
+            self.plan_runner.store.update_schedule(plan_id, next_run.isoformat() if next_run else None)
+
+    @staticmethod
+    def _plan_job_id(plan_id: str) -> str:
+        return f"continual-{plan_id}"
+
+    @staticmethod
+    def _plan_catchup_job_id(plan_id: str) -> str:
+        return f"continual-catchup-{plan_id}"
+
+    @staticmethod
+    def _plan_is_overdue(next_run_at: str | None) -> bool:
+        if not next_run_at:
+            return False
+        try:
+            return parse_iso(next_run_at) <= utc_now()
+        except ValueError:
+            return False
+
     def _schedule_existing(self, job: dict[str, Any]) -> None:
         if job["trigger_type"] == "cron":
             trigger = CronTrigger.from_crontab(job["trigger_value"])

traderai/server.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import asyncio
 import json
 import shutil
 import subprocess
@@ -23,8 +24,10 @@ from traderai.config import save_settings, settings_payload
 from traderai.config import get_settings
 from traderai.cornerstone_client import CornerstoneClient
 from traderai.memory import DEFAULT_THREAD_ID, MemoryStore
+from traderai.plans import ContinualPlanRunner, ContinualPlanStore
 from traderai.scheduler import WakeScheduler
 from traderai.scmdb_client import SCMDBClient
+from traderai.starcitizen_wiki_client import StarCitizenWikiClient
 from traderai.tools import ToolRegistry
 from traderai.uex_client import UEXClient
 from traderai.version import RELEASES_API_URL, RELEASES_URL, __version__
@@ -38,6 +41,13 @@ def resource_path(*parts: str) -> Path:
 class ChatRequest(BaseModel):
     message: str
     thread_id: str | None = DEFAULT_THREAD_ID
+    images: list["ChatImageRequest"] = []
+
+
+class ChatImageRequest(BaseModel):
+    name: str = "pasted-image.png"
+    content_type: str = "image/png"
+    image_data: str
 
 
 class ChatThreadRequest(BaseModel):
@@ -60,6 +70,27 @@ class ClearMemoryRequest(BaseModel):
     include_outbox: bool = True
 
 
+class ContinualPlanItemRequest(BaseModel):
+    item_name: str
+    desired_quantity: int = 1
+    max_unit_price: float | None = None
+
+
+class ContinualPlanCreateRequest(BaseModel):
+    title: str
+    objective: str
+    kind: str = "buying"
+    cadence: str | None = None
+    constraints: dict[str, Any] = {}
+    items: list[ContinualPlanItemRequest] = []
+
+
+class ContinualPlanEventRequest(BaseModel):
+    kind: str = "note"
+    message: str
+    metadata: dict[str, Any] = {}
+
+
 class ConfigUpdateRequest(BaseModel):
     values: dict
 
@@ -75,28 +106,54 @@ UPDATE_ASSET_NAME = "TraderAI.exe"
 def create_app() -> FastAPI:
     settings = get_settings()
     memory = MemoryStore(settings.traderai_memory_path)
+    plan_store = ContinualPlanStore(memory)
     scheduler = WakeScheduler(memory)
-    uex = UEXClient(settings.uex_base_url, settings.uex_secret_key, settings.uex_bearer_token)
+    runtime: dict[str, Any] = {}
-    scmdb = SCMDBClient(settings.scmdb_base_url)
+
-    cornerstone = CornerstoneClient(settings.cornerstone_base_url)
+    def configure_runtime(current_settings: Any) -> None:
-    tools = ToolRegistry(
+        uex = UEXClient(current_settings.uex_base_url, current_settings.uex_secret_key, current_settings.uex_bearer_token)
-        uex,
+        scmdb = SCMDBClient(current_settings.scmdb_base_url)
-        settings.require_write_approval,
+        cornerstone = CornerstoneClient(current_settings.cornerstone_base_url)
-        memory=memory,
+        scwiki = StarCitizenWikiClient(current_settings.scwiki_base_url, current_settings.scwiki_api_base_url)
-        scheduler=scheduler,
+        tools = ToolRegistry(
-        scmdb=scmdb,
+            uex,
-        cornerstone=cornerstone,
+            current_settings.require_write_approval,
-    )
+            memory=memory,
-    agent = OllamaAgent(
+            scheduler=scheduler,
-        settings.ollama_base_url,
+            scmdb=scmdb,
-        settings.ollama_model,
+            cornerstone=cornerstone,
-        tools,
+            scwiki=scwiki,
-        memory=memory,
+            plan_store=plan_store,
-        user_name=settings.traderai_user_name,
+        )
-        num_ctx=settings.ollama_num_ctx,
+        plan_runner = ContinualPlanRunner(plan_store, tools, memory)
-    )
+        tools.plan_runner = plan_runner
-    scheduler.bind_agent(agent)
+        provider_base_url, provider_model, provider_api_key = provider_settings(current_settings)
-    scheduler.bind_uex_notifications(uex, settings.uex_notification_poll_seconds)
+        agent = OllamaAgent(
+            provider_base_url,
+            provider_model,
+            tools,
+            memory=memory,
+            user_name=current_settings.traderai_user_name,
+            num_ctx=current_settings.ollama_num_ctx,
+            provider=current_settings.model_provider,
+            api_key=provider_api_key,
+            reasoning_effort=current_settings.model_reasoning_effort,
+        )
+        plan_runner.bind_agent(agent)
+        scheduler.bind_agent(agent)
+        scheduler.bind_plan_runner(plan_runner)
+        scheduler.bind_uex_notifications(uex, current_settings.uex_notification_poll_seconds)
+        runtime.update(
+            {
+                "settings": current_settings,
+                "uex": uex,
+                "tools": tools,
+                "plan_runner": plan_runner,
+                "agent": agent,
+            }
+        )
+
+    configure_runtime(settings)
 
     app = FastAPI(title="TraderAI")
     static_dir = resource_path("web")
@@ -112,17 +169,20 @@ def create_app() -> FastAPI:
         scheduler.shutdown()
 
     async def refresh_user_profile() -> None:
-        if settings.traderai_user_name:
+        current_settings = get_settings()
-            memory.set_profile("configured_name", settings.traderai_user_name)
+        agent = runtime["agent"]
-            agent.user_name = agent.user_name or settings.traderai_user_name
+        uex = runtime["uex"]
+        if current_settings.traderai_user_name:
+            memory.set_profile("configured_name", current_settings.traderai_user_name)
+            agent.user_name = agent.user_name or current_settings.traderai_user_name
 
         try:
             response = await uex.get_user(authenticated=True)
         except Exception as exc:
             memory.set_profile("uex_user_error", str(exc))
-            if settings.traderai_user_name:
+            if current_settings.traderai_user_name:
                 try:
-                    response = await uex.get_user(username=settings.traderai_user_name)
+                    response = await uex.get_user(username=current_settings.traderai_user_name)
                 except Exception:
                     return
             else:
@@ -141,8 +201,13 @@ def create_app() -> FastAPI:
 
     @app.get("/api/health")
     async def health() -> dict:
+        agent = runtime["agent"]
+        current_settings = get_settings()
+        inference = await agent.health()
         return {
-            "ollama": await agent.health(),
+            "inference": inference,
+            "ollama": inference,
+            "model_provider": current_settings.model_provider,
             "user": memory.get_profile(),
             "jobs": scheduler.list_jobs(),
             "app_data_dir": settings_payload()["app_data_dir"],
@@ -155,14 +220,61 @@ def create_app() -> FastAPI:
 
     @app.post("/api/config")
     async def update_config(request: ConfigUpdateRequest) -> dict:
+        previous_settings = get_settings()
         updated = save_settings(request.values)
-        updated["restart_required"] = True
+        current_settings = get_settings()
-        updated["message"] = "Configuration saved. Restart TraderAI for all settings to take effect."
+        configure_runtime(current_settings)
+        await refresh_user_profile()
+        restart_required = (
+            "traderai_memory_path" in request.values
+            and str(request.values.get("traderai_memory_path") or "").strip() != str(previous_settings.traderai_memory_path)
+        )
+        updated["restart_required"] = restart_required
+        updated["message"] = (
+            "Configuration saved. Restart TraderAI to switch memory databases."
+            if restart_required
+            else "Configuration saved and applied."
+        )
         return updated
 
     @app.get("/api/ollama/status")
     async def ollama_status() -> dict:
-        return await inspect_ollama()
+        return await inspect_model_provider()
+
+    @app.get("/api/provider/models")
+    async def provider_models(provider: str | None = None) -> dict:
+        status = await inspect_provider_models(provider)
+        return {
+            "provider": status.get("provider", "openai"),
+            "configured_model": status.get("configured_model"),
+            "models": status.get("models", []),
+            "reasoning_efforts": status.get("reasoning_efforts", reasoning_effort_options()),
+            "configured_reasoning_effort": status.get("configured_reasoning_effort", get_settings().model_reasoning_effort),
+            "message": status.get("message", ""),
+            "detail": status.get("detail", ""),
+            "online": status.get("online", False),
+        }
+
+    @app.post("/api/codex/login")
+    async def launch_codex_login() -> dict:
+        current_settings = get_settings()
+        command = find_codex_cli(current_settings.codex_command)
+        if not command:
+            raise HTTPException(status_code=404, detail="Codex CLI was not found on PATH.")
+        try:
+            login = await start_codex_browser_login(command)
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=f"Codex App Server login failed: {exception_detail(exc)}") from exc
+        return {
+            "installed": True,
+            "running": False,
+            "online": False,
+            "provider": "codex",
+            "login_id": login.get("loginId"),
+            "auth_url": login.get("authUrl"),
+            "base_url": str(command),
+            "message": "Opened Codex App Server sign-in in your browser. Finish the flow, then TraderAI will detect the new login.",
+        }
 
     @app.post("/api/ollama/launch")
     async def launch_ollama() -> dict:
@@ -173,7 +285,7 @@ def create_app() -> FastAPI:
             popen_hidden(command)
         except OSError as exc:
             raise HTTPException(status_code=500, detail=f"Could not launch Ollama: {exc}") from exc
-        status = await inspect_ollama()
+        status = await inspect_model_provider()
         status["message"] = "Ollama launch requested."
         return status
 
@@ -190,7 +302,7 @@ def create_app() -> FastAPI:
             popen_hidden([str(cli), "pull", model])
         except OSError as exc:
             raise HTTPException(status_code=500, detail=f"Could not start model install: {exc}") from exc
-        status = await inspect_ollama()
+        status = await inspect_model_provider()
         status["message"] = f"Started installing model {model}."
         return status
 
@@ -269,15 +381,26 @@ def create_app() -> FastAPI:
 
     @app.post("/api/chat")
     async def chat(request: ChatRequest) -> dict:
+        agent = runtime["agent"]
         try:
-            return await agent.chat(request.message, thread_id=request.thread_id)
+            return await agent.chat(
+                request.message,
+                thread_id=request.thread_id,
+                images=[image.model_dump() for image in request.images],
+            )
         except OllamaUnavailable as exc:
             raise HTTPException(status_code=503, detail=str(exc)) from exc
 
     @app.post("/api/chat/stream")
     async def chat_stream(request: ChatRequest) -> StreamingResponse:
+        agent = runtime["agent"]
+
         async def events():
-            async for event in agent.chat_events(request.message, thread_id=request.thread_id):
+            async for event in agent.chat_events(
+                request.message,
+                thread_id=request.thread_id,
+                images=[image.model_dump() for image in request.images],
+            ):
                 yield f"data: {json.dumps(event)}\n\n"
 
         return StreamingResponse(events(), media_type="text/event-stream")
@@ -309,6 +432,7 @@ def create_app() -> FastAPI:
 
     @app.get("/api/pending-actions")
     async def pending_actions() -> dict:
+        agent = runtime["agent"]
         return {"pending_actions": agent._pending_payloads()}
 
     @app.get("/api/notifications")
@@ -335,11 +459,13 @@ def create_app() -> FastAPI:
 
     @app.get("/api/negotiations/{identifier}/messages")
     async def negotiation_messages(identifier: str) -> dict:
+        uex = runtime["uex"]
         params = negotiation_identifier_params(identifier)
         return await uex.get("marketplace_negotiations_messages", params, authenticated=True)
 
     @app.post("/api/negotiations/{identifier}/messages")
     async def send_negotiation_message(identifier: str, request: DirectNegotiationMessageRequest) -> dict:
+        uex = runtime["uex"]
         params = negotiation_identifier_params(identifier)
         payload = {**params, "message": request.message, "is_production": 1}
         return await uex.post("marketplace_negotiations_messages", payload, authenticated=True)
@@ -348,6 +474,79 @@ def create_app() -> FastAPI:
     async def wake_jobs() -> dict:
         return {"scheduled_jobs": scheduler.list_jobs()}
 
+    @app.get("/api/plans")
+    async def continual_plans(include_inactive: bool = True) -> dict:
+        return {"plans": plan_store.list_plans(include_inactive=include_inactive)}
+
+    @app.post("/api/plans")
+    async def create_continual_plan(request: ContinualPlanCreateRequest) -> dict:
+        tools = runtime["tools"]
+        result = await tools.create_continual_plan(
+            title=request.title,
+            objective=request.objective,
+            kind=request.kind,
+            items=[item.model_dump() for item in request.items],
+            constraints=request.constraints,
+            cadence=request.cadence,
+        )
+        if result.get("error"):
+            raise HTTPException(status_code=400, detail=result["error"])
+        return result
+
+    @app.get("/api/plans/{plan_id}")
+    async def continual_plan(plan_id: str) -> dict:
+        plan = plan_store.get_plan(plan_id)
+        if not plan:
+            raise HTTPException(status_code=404, detail="Plan not found.")
+        return {"plan": plan}
+
+    @app.post("/api/plans/{plan_id}/pause")
+    async def pause_continual_plan(plan_id: str) -> dict:
+        tools = runtime["tools"]
+        result = await tools.pause_continual_plan(plan_id)
+        if result.get("error"):
+            raise HTTPException(status_code=404, detail=result["error"])
+        return result
+
+    @app.post("/api/plans/{plan_id}/resume")
+    async def resume_continual_plan(plan_id: str) -> dict:
+        tools = runtime["tools"]
+        result = await tools.resume_continual_plan(plan_id)
+        if result.get("error"):
+            raise HTTPException(status_code=404, detail=result["error"])
+        return result
+
+    @app.post("/api/plans/{plan_id}/cancel")
+    async def cancel_continual_plan(plan_id: str) -> dict:
+        tools = runtime["tools"]
+        result = await tools.cancel_continual_plan(plan_id)
+        if result.get("error"):
+            raise HTTPException(status_code=404, detail=result["error"])
+        return result
+
+    @app.delete("/api/plans/{plan_id}")
+    async def delete_continual_plan(plan_id: str) -> dict:
+        tools = runtime["tools"]
+        result = await tools.delete_continual_plan(plan_id)
+        if result.get("error"):
+            raise HTTPException(status_code=404, detail=result["error"])
+        return result
+
+    @app.post("/api/plans/{plan_id}/run")
+    async def run_continual_plan(plan_id: str) -> dict:
+        tools = runtime["tools"]
+        result = await tools.run_continual_plan_now(plan_id)
+        if result.get("error"):
+            raise HTTPException(status_code=400, detail=result["error"])
+        return result
+
+    @app.post("/api/plans/{plan_id}/events")
+    async def add_continual_plan_event(plan_id: str, request: ContinualPlanEventRequest) -> dict:
+        if not plan_store.get_plan(plan_id):
+            raise HTTPException(status_code=404, detail="Plan not found.")
+        event = plan_store.add_event(plan_id, request.kind, request.message, request.metadata)
+        return {"event": event, "plan": plan_store.get_plan(plan_id)}
+
     @app.get("/api/memory")
     async def inspect_memory(limit: int = 50) -> dict:
         return memory.inspect(max(1, min(limit, 200)))
@@ -369,10 +568,12 @@ def create_app() -> FastAPI:
 
     @app.post("/api/approve/{action_id}")
     async def approve(action_id: str) -> dict:
+        tools = runtime["tools"]
         return await tools.approve(action_id)
 
     @app.post("/api/decline/{action_id}")
     async def decline(action_id: str) -> dict:
+        tools = runtime["tools"]
         return await tools.decline(action_id)
 
     return app
@@ -387,6 +588,125 @@ def negotiation_identifier_params(identifier: str) -> dict[str, Any]:
     return {"hash": value}
 
 
+async def inspect_model_provider() -> dict[str, Any]:
+    settings = get_settings()
+    if settings.model_provider == "openai":
+        return await inspect_openai()
+    if settings.model_provider == "codex":
+        return await inspect_codex()
+    return await inspect_ollama()
+
+
+async def inspect_openai() -> dict[str, Any]:
+    settings = get_settings()
+    return await inspect_cloud_provider_config("openai", settings.openai_base_url, settings.openai_api_key, settings.openai_model)
+
+
+async def inspect_codex() -> dict[str, Any]:
+    settings = get_settings()
+    command = find_codex_cli(settings.codex_command)
+    detail = ""
+    online = False
+    models: list[str] = []
+    effort_map: dict[str, list[str]] = {}
+    if command:
+        try:
+            account, models, effort_map = await inspect_codex_app_server(command)
+            online = bool(account)
+            detail = f"Logged in as {account.get('email')}" if isinstance(account, dict) and account.get("email") else ""
+        except (OSError, RuntimeError, asyncio.TimeoutError) as exc:
+            detail = str(exc)
+    configured_model = settings.codex_model
+    model_available = configured_model in models if models else bool(configured_model)
+    return {
+        "installed": bool(command),
+        "running": online,
+        "online": online,
+        "provider": "codex",
+        "model_available": model_available,
+        "configured_model": configured_model,
+        "configured_reasoning_effort": settings.model_reasoning_effort,
+        "reasoning_efforts": codex_reasoning_efforts(configured_model, effort_map),
+        "base_url": str(command) if command else settings.codex_command,
+        "models": models,
+        "message": codex_status_message(bool(command), online, model_available, configured_model),
+        "detail": detail,
+    }
+
+
+async def inspect_cloud_provider() -> dict[str, Any]:
+    settings = get_settings()
+    if settings.model_provider == "codex":
+        return await inspect_codex()
+    return await inspect_openai()
+
+
+async def inspect_provider_models(provider: str | None = None) -> dict[str, Any]:
+    normalized = str(provider or get_settings().model_provider).strip().casefold()
+    if normalized == "codex":
+        return await inspect_codex()
+    if normalized == "ollama":
+        return await inspect_ollama()
+    return await inspect_openai()
+
+
+async def inspect_cloud_provider_config(
+    provider: str,
+    base_url: str,
+    api_key: str | None,
+    model: str,
+) -> dict[str, Any]:
+    settings = get_settings()
+    models: list[str] = []
+    online = False
+    detail = ""
+    provider_name = provider_display_name(provider)
+    if not api_key:
+        return {
+            "installed": True,
+            "running": False,
+            "online": False,
+            "provider": provider,
+            "model_available": False,
+            "configured_model": model,
+            "configured_reasoning_effort": settings.model_reasoning_effort,
+            "reasoning_efforts": reasoning_effort_options(),
+            "base_url": base_url,
+            "models": [],
+            "message": f"{provider_name} is selected, but no API key is configured.",
+            "detail": "",
+        }
+
+    try:
+        async with httpx.AsyncClient(timeout=10) as client:
+            response = await client.get(
+                f"{base_url.rstrip('/')}/models",
+                headers={"Authorization": f"Bearer {api_key}"},
+            )
+        response.raise_for_status()
+        body = response.json()
+        online = True
+        models = sorted(item.get("id") for item in body.get("data", []) if item.get("id"))
+    except (httpx.HTTPError, ValueError) as exc:
+        detail = str(exc)
+
+    model_available = model in models
+    return {
+        "installed": True,
+        "running": online,
+        "online": online,
+        "provider": provider,
+        "model_available": model_available,
+        "configured_model": model,
+        "configured_reasoning_effort": settings.model_reasoning_effort,
+        "reasoning_efforts": reasoning_effort_options(),
+        "base_url": base_url,
+        "models": models,
+        "message": cloud_status_message(provider, online, bool(api_key), model_available, model),
+        "detail": detail,
+    }
+
+
 async def inspect_ollama() -> dict[str, Any]:
     settings = get_settings()
     executable = find_ollama_executable()
@@ -412,8 +732,11 @@ async def inspect_ollama() -> dict[str, Any]:
         "installed": installed,
         "running": online,
         "online": online,
+        "provider": "ollama",
         "model_available": model_available,
         "configured_model": settings.ollama_model,
+        "configured_reasoning_effort": settings.model_reasoning_effort,
+        "reasoning_efforts": reasoning_effort_options(),
         "base_url": settings.ollama_base_url,
         "num_ctx": settings.ollama_num_ctx,
         "models": models,
@@ -426,6 +749,17 @@ async def inspect_ollama() -> dict[str, Any]:
     }
 
 
+def cloud_status_message(provider: str, running: bool, configured: bool, model_available: bool, model: str) -> str:
+    provider_name = provider_display_name(provider)
+    if not configured:
+        return f"{provider_name} API key is not configured."
+    if not running:
+        return f"{provider_name} is not reachable with the configured key."
+    if not model_available:
+        return f'{provider_name} is reachable, but model "{model}" was not returned by the API.'
+    return f"{provider_name} is ready."
+
+
 def ollama_status_message(installed: bool, running: bool, model_available: bool, model: str) -> str:
     if not installed:
         return "Ollama is not installed."
@@ -436,6 +770,292 @@ def ollama_status_message(installed: bool, running: bool, model_available: bool,
     return "Ollama is ready."
 
 
+def codex_status_message(installed: bool, logged_in: bool, model_available: bool, model: str) -> str:
+    if not installed:
+        return "Codex CLI is not installed."
+    if not logged_in:
+        return "Codex CLI is installed, but the Codex App Server is not logged in with ChatGPT."
+    if not model_available:
+        return f'Codex App Server is logged in, but model "{model}" was not returned by the model list.'
+    return "Codex App Server is ready."
+
+
+def provider_settings(settings: Any) -> tuple[str, str, str | None]:
+    if settings.model_provider == "openai":
+        return settings.openai_base_url, settings.openai_model, settings.openai_api_key
+    if settings.model_provider == "codex":
+        return settings.codex_command, settings.codex_model, None
+    return settings.ollama_base_url, settings.ollama_model, None
+
+
+def provider_display_name(provider: str) -> str:
+    return {"openai": "OpenAI", "codex": "Codex"}.get(provider, "Ollama")
+
+
+def find_codex_cli(configured_command: str | None = None) -> Path | None:
+    candidates = [configured_command, shutil.which("codex"), os.path.join(os.environ.get("USERPROFILE", ""), ".codex", ".sandbox-bin", "codex.exe")]
+    for candidate in candidates:
+        if not candidate:
+            continue
+        resolved = shutil.which(candidate) if Path(candidate).name == candidate else candidate
+        if not resolved:
+            continue
+        path = Path(resolved)
+        if path.exists():
+            return path
+    return None
+
+
+_codex_login_tasks: set[asyncio.Task] = set()
+
+
+async def start_codex_browser_login(command: Path) -> dict[str, Any]:
+    process = await asyncio.create_subprocess_exec(
+        str(command),
+        "app-server",
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0,
+    )
+    request_id = 1
+
+    async def write(payload: dict[str, Any]) -> None:
+        if process.stdin is None:
+            raise RuntimeError("Codex App Server stdin is unavailable.")
+        process.stdin.write((json.dumps(payload, ensure_ascii=True) + "\n").encode("utf-8"))
+        await process.stdin.drain()
+
+    async def read(timeout: int = 30) -> dict[str, Any]:
+        if process.stdout is None:
+            raise RuntimeError("Codex App Server stdout is unavailable.")
+        try:
+            line = await asyncio.wait_for(process.stdout.readline(), timeout=timeout)
+        except asyncio.TimeoutError as exc:
+            raise RuntimeError("Codex App Server timed out while starting browser login.") from exc
+        if not line:
+            stderr = ""
+            if process.stderr is not None:
+                try:
+                    stderr = (await asyncio.wait_for(process.stderr.read(), timeout=1)).decode("utf-8", errors="replace").strip()
+                except asyncio.TimeoutError:
+                    stderr = ""
+            raise RuntimeError(stderr or "Codex App Server exited before login completed.")
+        return json.loads(line.decode("utf-8", errors="replace"))
+
+    async def send(method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        nonlocal request_id
+        current_id = request_id
+        request_id += 1
+        payload: dict[str, Any] = {"jsonrpc": "2.0", "id": current_id, "method": method}
+        if params is not None:
+            payload["params"] = params
+        await write(payload)
+        while True:
+            message = await read()
+            if message.get("id") == current_id:
+                if message.get("error"):
+                    error = message["error"]
+                    raise RuntimeError(error.get("message") or f"Codex App Server request failed: {error}")
+                return message.get("result") or {}
+            await answer_codex_login_server_request(write, message)
+
+    try:
+        await send(
+            "initialize",
+            {
+                "clientInfo": {"name": "TraderAI", "version": __version__},
+                "capabilities": {"experimentalApi": True},
+            },
+        )
+        await write({"jsonrpc": "2.0", "method": "initialized", "params": {}})
+        login = await send("account/login/start", {"type": "chatgpt"})
+        if login.get("type") != "chatgpt" or not login.get("authUrl"):
+            raise RuntimeError(f"Codex App Server did not return a browser login URL: {login!r}")
+        task = asyncio.create_task(watch_codex_browser_login(process, read, write, login.get("loginId")))
+        _codex_login_tasks.add(task)
+        task.add_done_callback(_codex_login_tasks.discard)
+        return login
+    except Exception:
+        await stop_process(process)
+        raise
+
+
+async def answer_codex_login_server_request(write: Any, message: dict[str, Any]) -> None:
+    if "id" not in message or "method" not in message:
+        return
+    await write(
+        {
+            "jsonrpc": "2.0",
+            "id": message["id"],
+            "error": {"code": -32601, "message": "TraderAI login does not handle server requests."},
+        }
+    )
+
+
+async def watch_codex_browser_login(process: asyncio.subprocess.Process, read: Any, write: Any, login_id: str | None) -> None:
+    try:
+        while True:
+            message = await read(timeout=300)
+            if message.get("method") == "account/login/completed":
+                params = message.get("params") or {}
+                if login_id is None or params.get("loginId") == login_id:
+                    return
+            await answer_codex_login_server_request(write, message)
+    except Exception:
+        return
+    finally:
+        await stop_process(process)
+
+
+async def stop_process(process: asyncio.subprocess.Process) -> None:
+    if process.returncode is not None:
+        return
+    process.terminate()
+    try:
+        await asyncio.wait_for(process.wait(), timeout=3)
+    except asyncio.TimeoutError:
+        process.kill()
+        await process.wait()
+
+
+async def inspect_codex_app_server(command: Path) -> tuple[dict[str, Any] | None, list[str], dict[str, list[str]]]:
+    process = await asyncio.create_subprocess_exec(
+        str(command),
+        "app-server",
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0,
+    )
+    request_id = 1
+
+    async def write(payload: dict[str, Any]) -> None:
+        if process.stdin is None:
+            raise RuntimeError("Codex App Server stdin is unavailable.")
+        process.stdin.write((json.dumps(payload, ensure_ascii=True) + "\n").encode("utf-8"))
+        await process.stdin.drain()
+
+    async def read(timeout: int = 30) -> dict[str, Any]:
+        if process.stdout is None:
+            raise RuntimeError("Codex App Server stdout is unavailable.")
+        line = await asyncio.wait_for(process.stdout.readline(), timeout=timeout)
+        if not line:
+            stderr = ""
+            if process.stderr is not None:
+                try:
+                    stderr = (await asyncio.wait_for(process.stderr.read(), timeout=1)).decode("utf-8", errors="replace").strip()
+                except asyncio.TimeoutError:
+                    stderr = ""
+            raise RuntimeError(stderr or "Codex App Server exited without a response.")
+        return json.loads(line.decode("utf-8", errors="replace"))
+
+    async def send(method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        nonlocal request_id
+        current_id = request_id
+        request_id += 1
+        payload: dict[str, Any] = {"jsonrpc": "2.0", "id": current_id, "method": method}
+        if params is not None:
+            payload["params"] = params
+        await write(payload)
+        while True:
+            message = await read()
+            if message.get("id") == current_id:
+                if message.get("error"):
+                    error = message["error"]
+                    raise RuntimeError(error.get("message") or f"Codex App Server request failed: {error}")
+                return message.get("result") or {}
+            if "id" in message and "method" in message:
+                await write(
+                    {
+                        "jsonrpc": "2.0",
+                        "id": message["id"],
+                        "error": {"code": -32601, "message": "TraderAI status checks do not handle server requests."},
+                    }
+                )
+
+    try:
+        await send(
+            "initialize",
+            {
+                "clientInfo": {"name": "TraderAI", "version": __version__},
+                "capabilities": {"experimentalApi": True},
+            },
+        )
+        await write({"jsonrpc": "2.0", "method": "initialized", "params": {}})
+        account_result = await send("account/read", {"refreshToken": False})
+        models: list[str] = []
+        effort_map: dict[str, list[str]] = {}
+        cursor: str | None = None
+        for _ in range(20):
+            params: dict[str, Any] = {"limit": 50, "includeHidden": False}
+            if cursor:
+                params["cursor"] = cursor
+            page = await send("model/list", params)
+            for item in page.get("data") or []:
+                model = item.get("id") or item.get("model")
+                if not model:
+                    continue
+                models.append(model)
+                efforts = [
+                    effort.get("reasoningEffort")
+                    for effort in item.get("supportedReasoningEfforts", [])
+                    if effort.get("reasoningEffort")
+                ]
+                if efforts:
+                    effort_map[model] = efforts
+            cursor = page.get("nextCursor")
+            if not cursor:
+                break
+        return account_result.get("account"), sorted(set(models)), effort_map
+    finally:
+        if process.returncode is None:
+            process.terminate()
+            try:
+                await asyncio.wait_for(process.wait(), timeout=3)
+            except asyncio.TimeoutError:
+                process.kill()
+                await process.wait()
+
+
+def codex_models() -> list[str]:
+    cache_path = Path.home() / ".codex" / "models_cache.json"
+    if not cache_path.exists():
+        return []
+    try:
+        body = json.loads(cache_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return []
+    models = []
+    for item in body.get("models", []):
+        slug = item.get("slug")
+        if slug:
+            models.append(slug)
+    return sorted(set(models))
+
+
+def codex_reasoning_efforts(model: str, effort_map: dict[str, list[str]] | None = None) -> list[str]:
+    if effort_map and effort_map.get(model):
+        return effort_map[model]
+    cache_path = Path.home() / ".codex" / "models_cache.json"
+    if not cache_path.exists():
+        return reasoning_effort_options()
+    try:
+        body = json.loads(cache_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return reasoning_effort_options()
+    for item in body.get("models", []):
+        if item.get("slug") != model:
+            continue
+        efforts = [entry.get("effort") for entry in item.get("supported_reasoning_levels", []) if entry.get("effort")]
+        return efforts or reasoning_effort_options()
+    return reasoning_effort_options()
+
+
+def reasoning_effort_options() -> list[str]:
+    return ["none", "minimal", "low", "medium", "high", "xhigh"]
+
+
 def find_ollama_executable() -> Path | None:
     candidates = [
         shutil.which("ollama"),
@@ -488,6 +1108,13 @@ def popen_hidden(command: list[str]) -> subprocess.Popen:
     return subprocess.Popen(command, **kwargs)
 
 
+def exception_detail(exc: BaseException) -> str:
+    text = str(exc).strip()
+    if text:
+        return text
+    return f"{type(exc).__name__}: {exc!r}"
+
+
 async def inspect_update() -> dict[str, Any]:
     try:
         latest = await latest_release()

traderai/starcitizen_wiki_client.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+
+class StarCitizenWikiError(RuntimeError):
+    pass
+
+
+class StarCitizenWikiClient:
+    def __init__(
+        self,
+        base_url: str = "https://starcitizen.tools",
+        api_base_url: str = "https://api.star-citizen.wiki",
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_base_url = api_base_url.rstrip("/")
+
+    async def search_pages(self, query: str, limit: int = 5) -> list[dict[str, Any]]:
+        body = await self._get_json(
+            f"{self.base_url}/api.php",
+            params={
+                "action": "query",
+                "generator": "prefixsearch",
+                "gpssearch": query,
+                "gpslimit": max(1, min(limit, 10)),
+                "prop": "description|pageimages|extracts",
+                "exintro": 1,
+                "explaintext": 1,
+                "exchars": 320,
+                "piprop": "thumbnail",
+                "pithumbsize": 240,
+                "format": "json",
+            },
+        )
+        pages = body.get("query", {}).get("pages", {})
+        ordered = sorted(
+            (item for item in pages.values() if isinstance(item, dict)),
+            key=lambda item: int(item.get("index") or 0),
+        )
+        return [
+            {
+                "pageid": item.get("pageid"),
+                "title": item.get("title"),
+                "description": item.get("description"),
+                "extract": item.get("extract"),
+                "thumbnail": (item.get("thumbnail") or {}).get("source"),
+                "url": f"{self.base_url}/{quote(str(item.get('title') or '').replace(' ', '_'), safe=':/_')}",
+            }
+            for item in ordered
+            if item.get("title")
+        ]
+
+    async def get_page_summary(self, title: str | None = None, pageid: int | None = None, chars: int = 700) -> dict[str, Any] | None:
+        params: dict[str, Any] = {
+            "action": "query",
+            "prop": "extracts|description|pageimages",
+            "exintro": 1,
+            "explaintext": 1,
+            "exchars": max(120, min(chars, 1200)),
+            "piprop": "thumbnail",
+            "pithumbsize": 320,
+            "format": "json",
+        }
+        if pageid is not None:
+            params["pageids"] = pageid
+        elif title:
+            params["titles"] = title
+        else:
+            raise StarCitizenWikiError("title or pageid is required")
+
+        body = await self._get_json(f"{self.base_url}/api.php", params=params)
+        pages = body.get("query", {}).get("pages", {})
+        for item in pages.values():
+            if isinstance(item, dict) and item.get("pageid") and item.get("title"):
+                return {
+                    "pageid": item.get("pageid"),
+                    "title": item.get("title"),
+                    "description": item.get("description"),
+                    "extract": item.get("extract"),
+                    "thumbnail": (item.get("thumbnail") or {}).get("source"),
+                    "url": f"{self.base_url}/{quote(str(item.get('title') or '').replace(' ', '_'), safe=':/_')}",
+                }
+        return None
+
+    async def search_verse(self, query: str) -> list[dict[str, Any]]:
+        body = await self._get_json(
+            f"{self.api_base_url}/api/search",
+            params={"filter[query]": query},
+        )
+        data = body.get("data")
+        return data if isinstance(data, list) else []
+
+    async def get_vehicle(self, slug: str) -> dict[str, Any]:
+        body = await self._get_json(f"{self.api_base_url}/api/vehicles/{slug.strip('/')}")
+        data = body.get("data")
+        if not isinstance(data, dict):
+            raise StarCitizenWikiError(f"Vehicle response for {slug} was not an object.")
+        return data
+
+    async def _get_json(self, url: str, params: dict[str, Any] | None = None) -> Any:
+        async with httpx.AsyncClient(timeout=30, follow_redirects=True) as client:
+            response = await client.get(url, params=params, headers={"Accept": "application/json"})
+        try:
+            body = response.json()
+        except ValueError as exc:
+            raise StarCitizenWikiError(f"Star Citizen Wiki returned non-JSON response: HTTP {response.status_code}") from exc
+        if response.status_code >= 400:
+            raise StarCitizenWikiError(f"Star Citizen Wiki HTTP {response.status_code}: {body}")
+        return body

traderai/tools.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import uuid
+from contextlib import contextmanager
+from contextvars import ContextVar
 from dataclasses import dataclass
 from typing import Any, Awaitable, Callable
 
@@ -8,6 +10,7 @@ from traderai.cornerstone_client import CornerstoneClient, parse_cornerstone_ite
 from traderai.memory import MemoryStore
 from traderai.scheduler import WakeScheduler
 from traderai.scmdb_client import SCMDBClient
+from traderai.starcitizen_wiki_client import StarCitizenWikiClient
 from traderai.uex_client import UEXClient
 
 
@@ -56,10 +59,14 @@ UEX_GET_RESOURCES: dict[str, dict[str, Any]] = {
     "marketplace_averages": {"params": ["id_item", "item_name", "item_slug"], "auth": False, "group": "marketplace"},
     "marketplace_averages_all": {"params": [], "auth": False, "group": "marketplace", "heavy": True},
     "marketplace_favorites": {"params": ["id_listing"], "auth": True, "group": "marketplace"},
-    "marketplace_listings": {"params": ["id", "slug", "username"], "auth": False, "group": "marketplace"},
+    "marketplace_listings": {"params": ["id", "slug", "username", "id_item", "operation"], "auth": False, "group": "marketplace"},
     "marketplace_negotiations": {"params": ["id", "id_listing", "hash"], "auth": True, "group": "marketplace"},
     "marketplace_negotiations_messages": {"params": ["hash", "id_negotiation"], "auth": True, "group": "marketplace"},
-    "marketplace_prices_averages": {"params": ["id_item", "item_name", "item_slug"], "auth": False, "group": "marketplace"},
+    "marketplace_prices_averages": {
+        "params": ["id_item", "item_name", "item_slug", "id_category", "currency", "quality_tier"],
+        "auth": False,
+        "group": "marketplace",
+    },
     "marketplace_prices_averages_all": {"params": [], "auth": False, "group": "marketplace", "heavy": True},
     "marketplace_prices_history": {
         "params": [
@@ -81,7 +88,11 @@ UEX_GET_RESOURCES: dict[str, dict[str, Any]] = {
         "group": "marketplace",
         "history": True,
     },
-    "marketplace_trends": {"params": ["id_item", "item_name", "item_slug"], "auth": False, "group": "marketplace"},
+    "marketplace_trends": {
+        "params": ["id_item", "item_name", "item_slug", "id_category", "currency", "quality_tier"],
+        "auth": False,
+        "group": "marketplace",
+    },
     "moons": {"params": ["id", "id_planet", "id_star_system", "name", "slug"], "auth": False, "group": "locations"},
     "orbits": {"params": ["id", "id_star_system", "name", "slug"], "auth": False, "group": "locations"},
     "orbits_distances": {"params": ["id_origin", "id_destination"], "auth": False, "group": "locations"},
@@ -148,6 +159,7 @@ class PendingAction:
     endpoint: str
     payload: dict[str, Any]
     method: str = "POST"
+    metadata: dict[str, Any] | None = None
 
 
 class ToolRegistry:
@@ -159,17 +171,25 @@ class ToolRegistry:
         scheduler: WakeScheduler | None = None,
         scmdb: SCMDBClient | None = None,
         cornerstone: CornerstoneClient | None = None,
+        scwiki: StarCitizenWikiClient | None = None,
+        plan_store: Any | None = None,
+        plan_runner: Any | None = None,
     ) -> None:
         self.uex = uex
         self.scmdb = scmdb or SCMDBClient()
         self.cornerstone = cornerstone or CornerstoneClient()
+        self.scwiki = scwiki or StarCitizenWikiClient()
         self.require_write_approval = require_write_approval
         self.memory = memory
         self.scheduler = scheduler
+        self.plan_store = plan_store
+        self.plan_runner = plan_runner
         self.pending_actions: dict[str, PendingAction] = {}
+        self._chat_images_var: ContextVar[list[dict[str, Any]]] = ContextVar("chat_images", default=[])
         self.handlers: dict[str, ToolHandler] = {
             "search_marketplace_listings": self.search_marketplace_listings,
             "get_marketplace_listing": self.get_marketplace_listing,
+            "get_marketplace_trends": self.get_marketplace_trends,
             "list_marketplace_negotiations": self.list_marketplace_negotiations,
             "get_negotiation_messages": self.get_negotiation_messages,
             "draft_negotiation_message": self.draft_negotiation_message,
@@ -178,12 +198,26 @@ class ToolRegistry:
             "recall_memory": self.recall_memory,
             "schedule_wake_job": self.schedule_wake_job,
             "list_wake_jobs": self.list_wake_jobs,
+            "create_continual_plan": self.create_continual_plan,
+            "list_continual_plans": self.list_continual_plans,
+            "get_continual_plan": self.get_continual_plan,
+            "pause_continual_plan": self.pause_continual_plan,
+            "resume_continual_plan": self.resume_continual_plan,
+            "cancel_continual_plan": self.cancel_continual_plan,
+            "delete_continual_plan": self.delete_continual_plan,
+            "run_continual_plan_now": self.run_continual_plan_now,
             "check_uex_notifications": self.check_uex_notifications,
             "list_scmdb_versions": self.list_scmdb_versions,
             "search_scmdb_missions": self.search_scmdb_missions,
             "get_scmdb_mission_rewards": self.get_scmdb_mission_rewards,
+            "search_scwiki_pages": self.search_scwiki_pages,
+            "get_scwiki_page": self.get_scwiki_page,
+            "search_scwiki_vehicles": self.search_scwiki_vehicles,
+            "get_scwiki_vehicle": self.get_scwiki_vehicle,
             "search_cornerstone_items": self.search_cornerstone_items,
             "get_cornerstone_item_locations": self.get_cornerstone_item_locations,
+            "get_cornerstone_item_media": self.get_cornerstone_item_media,
+            "draft_marketplace_listing_with_cornerstone_image": self.draft_marketplace_listing_with_cornerstone_image,
         }
         self.handlers["uex_api_catalog"] = self.uex_api_catalog
         self.handlers["uex_get"] = self.uex_get
@@ -209,6 +243,7 @@ class ToolRegistry:
             *self._uex_post_schemas(),
             *self._uex_delete_schemas(),
             *self._scmdb_schemas(),
+            *self._scwiki_schemas(),
             *self._cornerstone_schemas(),
             {
                 "type": "function",
@@ -244,6 +279,24 @@ class ToolRegistry:
                     },
                 },
             },
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_marketplace_trends",
+                    "description": "Fetch current UEX marketplace trend metrics for an item, including WTS and WTB averages plus negotiation counts.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "id_item": {"type": "integer"},
+                            "item_name": {"type": "string"},
+                            "item_slug": {"type": "string"},
+                            "id_category": {"type": "integer"},
+                            "currency": {"type": "string", "description": "Optional currency filter such as UEC, WIF, or MGS."},
+                            "quality_tier": {"type": "integer", "minimum": 0, "maximum": 7},
+                        },
+                    },
+                },
+            },
             {
                 "type": "function",
                 "function": {
@@ -285,6 +338,11 @@ class ToolRegistry:
                             "message": {"type": "string"},
                             "hash": {"type": "string"},
                             "id_negotiation": {"type": "integer"},
+                            "id_listing": {"type": "integer"},
+                            "plan_id": {"type": "string"},
+                            "plan_item_id": {"type": "integer"},
+                            "candidate_id": {"type": "integer"},
+                            "listing_slug": {"type": "string"},
                             "is_production": {"type": "integer", "enum": [0, 1], "default": 1},
                         },
                     },
@@ -294,7 +352,7 @@ class ToolRegistry:
                 "type": "function",
                 "function": {
                     "name": "draft_marketplace_listing",
-                    "description": "Draft a new UEX marketplace listing. Listing prices are in-game aUEC/UEC credits, not real-world dollars. This creates a pending action that must be approved before posting.",
+                    "description": "Draft a new UEX marketplace listing. Listing prices are in-game aUEC/UEC credits, not real-world dollars. This creates a pending action that must be approved before posting. Prefer draft_marketplace_listing_with_cornerstone_image for item posts when a Cornerstone image is useful.",
                     "parameters": {
                         "type": "object",
                         "required": ["id_category", "operation", "type", "unit", "title", "description", "price", "currency", "language"],
@@ -315,8 +373,21 @@ class ToolRegistry:
                             "source": {"type": "string"},
                             "availability": {"type": "string"},
                             "in_stock": {"type": "integer"},
-                            "hours_expiration": {"type": "integer"},
+                              "durability": {"type": "integer", "minimum": 0, "maximum": 100},
+                              "video_url": {"type": "string"},
+                              "image_data": {"type": "string", "description": "Base64 JPG or PNG image data for UEX upload."},
+                              "use_attached_image": {
+                                  "type": "boolean",
+                                  "description": "When true, reuse an image pasted into the current chat as the listing image_data.",
+                              },
+                              "attached_image_index": {
+                                  "type": "integer",
+                                  "minimum": 0,
+                                  "description": "Zero-based pasted image index to reuse when use_attached_image is true.",
+                              },
+                              "hours_expiration": {"type": "integer"},
                             "is_hidden": {"type": "integer", "enum": [0, 1]},
+                            "is_tv_allowed": {"type": "integer", "enum": [0, 1]},
                             "is_production": {"type": "integer", "enum": [0, 1], "default": 1},
                         },
                     },
@@ -376,6 +447,91 @@ class ToolRegistry:
                     "parameters": {"type": "object", "properties": {}},
                 },
             },
+            {
+                "type": "function",
+                "function": {
+                    "name": "create_continual_plan",
+                    "description": "Create a durable multi-run plan. Use this for long-running marketplace work over days. kind=buying uses structured listing/candidate tracking; kind=custom continues through an agent wake prompt. All UEX writes are draft-only for approval.",
+                    "parameters": {
+                        "type": "object",
+                        "required": ["title", "objective"],
+                        "properties": {
+                            "title": {"type": "string"},
+                            "objective": {"type": "string"},
+                            "kind": {"type": "string", "enum": ["buying", "custom"], "default": "buying"},
+                            "cadence": {"type": "string", "description": "Five-field cron expression, default every six hours."},
+                            "constraints": {"type": "object", "description": "Plan-specific options such as message_tone, excluded_sellers, preferred_locations, max_unit_price, or custom instructions."},
+                            "items": {
+                                "type": "array",
+                                "items": {
+                                    "type": "object",
+                                    "properties": {
+                                        "item_name": {"type": "string"},
+                                        "desired_quantity": {"type": "integer", "minimum": 1},
+                                        "max_unit_price": {"type": "number"},
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "list_continual_plans",
+                    "description": "List durable continual plans and their statuses.",
+                    "parameters": {"type": "object", "properties": {"include_inactive": {"type": "boolean", "default": True}}},
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_continual_plan",
+                    "description": "Get one continual plan with checklist items, candidates, negotiations, and event history.",
+                    "parameters": {"type": "object", "required": ["plan_id"], "properties": {"plan_id": {"type": "string"}}},
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "pause_continual_plan",
+                    "description": "Pause a continual plan so scheduled runs stop.",
+                    "parameters": {"type": "object", "required": ["plan_id"], "properties": {"plan_id": {"type": "string"}}},
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "resume_continual_plan",
+                    "description": "Resume a paused or needs-input continual plan. It only becomes active when it has checklist items.",
+                    "parameters": {"type": "object", "required": ["plan_id"], "properties": {"plan_id": {"type": "string"}}},
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "cancel_continual_plan",
+                    "description": "Cancel a continual plan.",
+                    "parameters": {"type": "object", "required": ["plan_id"], "properties": {"plan_id": {"type": "string"}}},
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "delete_continual_plan",
+                    "description": "Delete a continual plan and all of its stored checklist items, candidates, negotiations, and event history.",
+                    "parameters": {"type": "object", "required": ["plan_id"], "properties": {"plan_id": {"type": "string"}}},
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "run_continual_plan_now",
+                    "description": "Run one continual plan immediately and put the result in the Inbox.",
+                    "parameters": {"type": "object", "required": ["plan_id"], "properties": {"plan_id": {"type": "string"}}},
+                },
+            },
             {
                 "type": "function",
                 "function": {
@@ -395,18 +551,30 @@ class ToolRegistry:
         except Exception as exc:
             return {"error": str(exc)}
 
+    @contextmanager
+    def chat_image_scope(self, images: list[dict[str, Any]] | None):
+        token = self._chat_images_var.set(self._normalize_chat_images(images))
+        try:
+            yield
+        finally:
+            self._chat_images_var.reset(token)
+
     async def approve(self, action_id: str) -> dict[str, Any]:
         action = self.pending_actions.pop(action_id, None)
         if not action:
             return {"error": f"Pending action not found: {action_id}"}
         if action.method == "DELETE":
-            return await self.uex.delete(action.endpoint, action.payload, authenticated=True)
+            result = await self.uex.delete(action.endpoint, action.payload, authenticated=True)
-        return await self.uex.post(action.endpoint, self._production_payload(action.endpoint, action.payload), authenticated=True)
+        else:
+            result = await self.uex.post(action.endpoint, self._production_payload(action.endpoint, action.payload), authenticated=True)
+        self._record_pending_action_result(action, "approved", result)
+        return result
 
     async def decline(self, action_id: str) -> dict[str, Any]:
         action = self.pending_actions.pop(action_id, None)
         if not action:
             return {"error": f"Pending action not found: {action_id}"}
+        self._record_pending_action_result(action, "declined", {})
         return {
             "declined": True,
             "pending_action": {
@@ -414,7 +582,8 @@ class ToolRegistry:
                 "label": action.label,
                 "method": action.method,
                 "endpoint": action.endpoint,
-                "payload": action.payload,
+                "payload": self._display_payload(action.payload),
+                "metadata": action.metadata or {},
             },
         }
 
@@ -840,6 +1009,68 @@ class ToolRegistry:
             },
         ]
 
+    @classmethod
+    def _scwiki_schemas(cls) -> list[dict[str, Any]]:
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": "search_scwiki_pages",
+                    "description": "Search Star Citizen Wiki pages on starcitizen.tools and return concise summaries for general game knowledge.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "query": {"type": "string", "description": "Page title or topic to search for."},
+                            "limit": {"type": "integer", "minimum": 1, "maximum": 10, "default": 5},
+                        },
+                    },
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_scwiki_page",
+                    "description": "Fetch one Star Citizen Wiki page summary by title or page id.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "title": {"type": "string"},
+                            "pageid": {"type": "integer"},
+                            "chars": {"type": "integer", "minimum": 120, "maximum": 1200, "default": 700},
+                        },
+                    },
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "search_scwiki_vehicles",
+                    "description": "Search Star Citizen Wiki structured vehicle data for ships and vehicles.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "query": {"type": "string", "description": "Ship or vehicle name to search for."},
+                            "limit": {"type": "integer", "minimum": 1, "maximum": 10, "default": 5},
+                        },
+                    },
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_scwiki_vehicle",
+                    "description": "Fetch one Star Citizen Wiki vehicle summary, including MSRP and in-game purchase locations when available.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "slug": {"type": "string", "description": "Vehicle slug such as anvl-carrack."},
+                            "query": {"type": "string", "description": "Vehicle name if the slug is not known."},
+                        },
+                    },
+                },
+            },
+        ]
+
     @classmethod
     def _cornerstone_schemas(cls) -> list[dict[str, Any]]:
         return [
@@ -874,6 +1105,70 @@ class ToolRegistry:
                     },
                 },
             },
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_cornerstone_item_media",
+                    "description": "Fetch Cornerstone item page media, especially image URLs that can be used when drafting UEX marketplace listings.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "string", "description": "Cornerstone item id from search_cornerstone_items."},
+                            "query": {"type": "string", "description": "Item name if id is not known."},
+                            "limit": {"type": "integer", "minimum": 1, "maximum": 10, "default": 5},
+                        },
+                    },
+                },
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "draft_marketplace_listing_with_cornerstone_image",
+                    "description": "Draft a UEX marketplace listing and source the listing image from Cornerstone. The image is downloaded as base64 image_data and included in the pending action. Nothing is posted until user approval.",
+                    "parameters": {
+                        "type": "object",
+                        "required": ["item_query", "id_category", "operation", "type", "unit", "title", "description", "price", "currency", "language"],
+                        "properties": {
+                            "item_query": {"type": "string", "description": "Cornerstone item name to source an image from."},
+                            "cornerstone_id": {"type": "string", "description": "Cornerstone item id, if already known."},
+                            "id_item": {"type": "integer"},
+                            "id_star_system": {"type": "integer"},
+                            "id_terminal": {"type": "integer"},
+                            "id_organization": {"type": "integer"},
+                            "id_category": {"type": "integer"},
+                            "operation": {"type": "string", "enum": ["buy", "sell", "rent", "trade"]},
+                            "type": {"type": "string", "enum": ["item", "service", "contract"]},
+                            "unit": {"type": "string"},
+                            "title": {"type": "string"},
+                            "description": {"type": "string"},
+                            "price": {"type": "number"},
+                            "currency": {"type": "string", "enum": ["UEC"]},
+                            "language": {"type": "string", "default": "en_US"},
+                            "location": {"type": "string"},
+                            "source": {"type": "string", "enum": ["looted", "pledged", "purchased_in_game", "pirated", "gifted"]},
+                              "availability": {"type": "string"},
+                              "in_stock": {"type": "integer"},
+                              "durability": {"type": "integer", "minimum": 0, "maximum": 100},
+                              "video_url": {"type": "string"},
+                              "image_data": {"type": "string", "description": "Base64 JPG or PNG image data for UEX upload."},
+                              "use_attached_image": {
+                                  "type": "boolean",
+                                  "description": "When true, reuse an image pasted into the current chat as the listing image_data instead of sourcing from Cornerstone.",
+                              },
+                              "attached_image_index": {
+                                  "type": "integer",
+                                  "minimum": 0,
+                                  "description": "Zero-based pasted image index to reuse when use_attached_image is true.",
+                              },
+                              "hours_expiration": {"type": "integer"},
+                            "is_hidden": {"type": "integer", "enum": [0, 1]},
+                            "is_tv_allowed": {"type": "integer", "enum": [0, 1]},
+                            "is_production": {"type": "integer", "enum": [0, 1], "default": 1},
+                            "require_image": {"type": "boolean", "default": False, "description": "Return an error instead of drafting if no Cornerstone JPG/PNG image can be sourced."},
+                        },
+                    },
+                },
+            },
         ]
 
     @classmethod
@@ -1024,6 +1319,49 @@ class ToolRegistry:
         response = await self.uex.get("marketplace_listings", {"id": id, "slug": slug})
         return {"listing": response.get("data")}
 
+    async def get_marketplace_trends(
+        self,
+        id_item: int | None = None,
+        item_name: str | None = None,
+        item_slug: str | None = None,
+        id_category: int | None = None,
+        currency: str | None = None,
+        quality_tier: int | None = None,
+    ) -> dict[str, Any]:
+        response = await self.uex.get(
+            "marketplace_trends",
+            {
+                "id_item": id_item,
+                "item_name": item_name,
+                "item_slug": item_slug,
+                "id_category": id_category,
+                "currency": currency,
+                "quality_tier": quality_tier,
+            },
+        )
+        trends = [
+            self._summarize_marketplace_trend(item)
+            for item in self._as_list(response.get("data"))
+            if isinstance(item, dict)
+        ]
+        return {
+            "status": response.get("status"),
+            "count": len(trends),
+            "filters": {
+                key: value
+                for key, value in {
+                    "id_item": id_item,
+                    "item_name": item_name,
+                    "item_slug": item_slug,
+                    "id_category": id_category,
+                    "currency": currency,
+                    "quality_tier": quality_tier,
+                }.items()
+                if value is not None
+            },
+            "trends": trends,
+        }
+
     async def list_marketplace_negotiations(
         self,
         id: int | None = None,
@@ -1046,13 +1384,89 @@ class ToolRegistry:
         message: str,
         hash: str | None = None,
         id_negotiation: int | None = None,
+        id_listing: int | None = None,
+        plan_id: str | None = None,
+        plan_item_id: int | None = None,
+        candidate_id: int | None = None,
+        listing_slug: str | None = None,
         is_production: int = 1,
     ) -> dict[str, Any]:
-        payload = {"message": message, "hash": hash, "id_negotiation": id_negotiation, "is_production": is_production}
+        payload = {"message": message, "hash": hash, "id_negotiation": id_negotiation, "id_listing": id_listing, "is_production": is_production}
-        return self._pending("Send negotiation message", "marketplace_negotiations_messages", payload)
+        metadata = {
+            "plan_id": plan_id,
+            "plan_item_id": plan_item_id,
+            "candidate_id": candidate_id,
+            "listing_id": id_listing,
+            "listing_slug": listing_slug,
+            "hash": hash,
+            "id_negotiation": id_negotiation,
+        }
+        return self._pending("Send negotiation message", "marketplace_negotiations_messages", payload, metadata=metadata)
 
     async def draft_marketplace_listing(self, **payload: Any) -> dict[str, Any]:
-        return self._pending("Post marketplace listing", "marketplace_advertise", payload)
+        attached_image = self._attach_chat_image(payload)
+        if attached_image.get("error"):
+            return {"error": attached_image["error"]}
+        return self._pending(
+            "Post marketplace listing",
+            "marketplace_advertise",
+            payload,
+            metadata=attached_image.get("metadata"),
+        )
+
+    async def draft_marketplace_listing_with_cornerstone_image(
+        self,
+        item_query: str,
+        cornerstone_id: str | None = None,
+        **payload: Any,
+    ) -> dict[str, Any]:
+        require_image = bool(payload.pop("require_image", False))
+        attached_image = self._attach_chat_image(payload)
+        if attached_image.get("error"):
+            return {"error": attached_image["error"]}
+        item = await self._resolve_cornerstone_item(id=cornerstone_id, query=item_query)
+        if not item:
+            return {"error": "No Cornerstone item matched. Provide cornerstone_id or a more specific item_query."}
+
+        page = await self.cornerstone.get_item_page(str(item["id"]))
+        parsed = parse_cornerstone_item_page(page["html"], page["url"])
+        media = parsed.get("media") or []
+        image_result: dict[str, Any] | None = None
+        image_error = ""
+        for media_item in media:
+            try:
+                image_result = await self.cornerstone.get_image_data(media_item["url"])
+                break
+            except Exception as exc:
+                image_error = str(exc)
+
+        if image_result and not payload.get("image_data"):
+            payload["image_data"] = image_result["image_data"]
+        elif require_image and not payload.get("image_data"):
+            return {
+                "error": "Cornerstone item matched, but no usable JPG/PNG image could be sourced.",
+                "cornerstone": {
+                    "item": {"id": item.get("id"), "name": parsed.get("name") or item.get("name")},
+                    "url": page["url"],
+                    "media": media,
+                    "image_error": image_error,
+                },
+            }
+
+        payload.setdefault("id_item", self._int_or_none(item.get("id")))
+        metadata = {
+            "cornerstone_item_id": item.get("id"),
+            "cornerstone_item_name": parsed.get("name") or item.get("name"),
+            "cornerstone_url": page["url"],
+            "cornerstone_image_url": image_result.get("url") if image_result else None,
+            "cornerstone_image_content_type": image_result.get("content_type") if image_result else None,
+            "cornerstone_image_size_bytes": image_result.get("size_bytes") if image_result else None,
+            "cornerstone_image_status": "user_attached" if attached_image.get("metadata") else ("included" if image_result else "not_found"),
+            "cornerstone_image_error": image_error or None,
+        }
+        if attached_image.get("metadata"):
+            metadata.update(attached_image["metadata"])
+        return self._pending("Post marketplace listing with Cornerstone image", "marketplace_advertise", payload, metadata=metadata)
 
     async def remember_user_fact(self, content: str, kind: str = "note", importance: int = 3) -> dict[str, Any]:
         if self.memory is None:
@@ -1083,6 +1497,81 @@ class ToolRegistry:
             return {"error": "Scheduler is not configured."}
         return {"scheduled_jobs": self.scheduler.list_jobs()}
 
+    async def create_continual_plan(
+        self,
+        title: str,
+        objective: str,
+        kind: str = "buying",
+        items: list[dict[str, Any]] | None = None,
+        constraints: dict[str, Any] | None = None,
+        cadence: str | None = None,
+    ) -> dict[str, Any]:
+        if self.plan_store is None:
+            return {"error": "Continual plan store is not configured."}
+        plan = self.plan_store.create_plan(title, kind=kind, objective=objective, items=items or [], constraints=constraints or {}, cadence=cadence)
+        if self.scheduler is not None and plan.get("status") == "active":
+            self.scheduler.schedule_plan(plan)
+            plan = self.plan_store.get_plan(plan["id"]) or plan
+        return {"plan": plan}
+
+    async def list_continual_plans(self, include_inactive: bool = True) -> dict[str, Any]:
+        if self.plan_store is None:
+            return {"error": "Continual plan store is not configured."}
+        return {"plans": self.plan_store.list_plans(include_inactive=include_inactive)}
+
+    async def get_continual_plan(self, plan_id: str) -> dict[str, Any]:
+        if self.plan_store is None:
+            return {"error": "Continual plan store is not configured."}
+        plan = self.plan_store.get_plan(plan_id)
+        if not plan:
+            return {"error": f"Plan not found: {plan_id}"}
+        return {"plan": plan}
+
+    async def pause_continual_plan(self, plan_id: str) -> dict[str, Any]:
+        if self.plan_store is None:
+            return {"error": "Continual plan store is not configured."}
+        if self.scheduler is not None:
+            self.scheduler.unschedule_plan(plan_id)
+        return {"plan": self.plan_store.set_status(plan_id, "paused")}
+
+    async def resume_continual_plan(self, plan_id: str) -> dict[str, Any]:
+        if self.plan_store is None:
+            return {"error": "Continual plan store is not configured."}
+        plan = self.plan_store.get_plan(plan_id)
+        if not plan:
+            return {"error": f"Plan not found: {plan_id}"}
+        next_status = "active" if plan.get("items") else "needs_input"
+        plan = self.plan_store.set_status(plan_id, next_status)
+        if self.scheduler is not None and plan and plan.get("status") == "active":
+            self.scheduler.schedule_plan(plan)
+            plan = self.plan_store.get_plan(plan_id)
+        return {"plan": plan}
+
+    async def cancel_continual_plan(self, plan_id: str) -> dict[str, Any]:
+        if self.plan_store is None:
+            return {"error": "Continual plan store is not configured."}
+        if self.scheduler is not None:
+            self.scheduler.unschedule_plan(plan_id)
+        return {"plan": self.plan_store.set_status(plan_id, "canceled")}
+
+    async def delete_continual_plan(self, plan_id: str) -> dict[str, Any]:
+        if self.plan_store is None:
+            return {"error": "Continual plan store is not configured."}
+        plan = self.plan_store.get_plan(plan_id)
+        if not plan:
+            return {"error": f"Plan not found: {plan_id}"}
+        if self.scheduler is not None:
+            self.scheduler.unschedule_plan(plan_id)
+        deleted = self.plan_store.delete_plan(plan_id)
+        if not deleted:
+            return {"error": f"Plan not found: {plan_id}"}
+        return {"deleted": True, "plan_id": plan_id, "summary": f"Deleted plan {plan.get('title') or plan_id}."}
+
+    async def run_continual_plan_now(self, plan_id: str) -> dict[str, Any]:
+        if self.plan_runner is None:
+            return {"error": "Continual plan runner is not configured."}
+        return await self.plan_runner.run_plan(plan_id)
+
     async def check_uex_notifications(self) -> dict[str, Any]:
         response = await self.uex.get_user_notifications()
         notifications = response.get("notifications") or []
@@ -1208,6 +1697,49 @@ class ToolRegistry:
             "mission": self._summarize_scmdb_mission(data, mission, source=source, detailed=True),
         }
 
+    async def search_scwiki_pages(self, query: str, limit: int = 5) -> dict[str, Any]:
+        pages = await self.scwiki.search_pages(query, limit=limit)
+        return {"source": self.scwiki.base_url, "query": query, "matched": len(pages), "pages": pages}
+
+    async def get_scwiki_page(
+        self,
+        title: str | None = None,
+        pageid: int | None = None,
+        chars: int = 700,
+    ) -> dict[str, Any]:
+        page = await self.scwiki.get_page_summary(title=title, pageid=pageid, chars=chars)
+        if not page:
+            return {"error": "No Star Citizen Wiki page matched."}
+        return {"source": self.scwiki.base_url, "page": page}
+
+    async def search_scwiki_vehicles(self, query: str, limit: int = 5) -> dict[str, Any]:
+        groups = await self.scwiki.search_verse(query)
+        vehicles_group = next((item for item in groups if item.get("type") == "vehicles"), None)
+        results = [
+            self._summarize_scwiki_vehicle_search(item)
+            for item in (vehicles_group or {}).get("results", [])[: max(1, min(limit, 10))]
+            if isinstance(item, dict)
+        ]
+        return {"source": self.scwiki.api_base_url, "query": query, "matched": len(results), "vehicles": results}
+
+    async def get_scwiki_vehicle(self, slug: str | None = None, query: str | None = None) -> dict[str, Any]:
+        resolved_slug = slug
+        if not resolved_slug:
+            if not query:
+                return {"error": "Provide slug or query."}
+            groups = await self.scwiki.search_verse(query)
+            vehicles_group = next((item for item in groups if item.get("type") == "vehicles"), None)
+            candidates = [
+                item
+                for item in (vehicles_group or {}).get("results", [])
+                if isinstance(item, dict) and item.get("api_url")
+            ]
+            if not candidates:
+                return {"error": "No Star Citizen Wiki vehicle matched."}
+            resolved_slug = str(candidates[0]["api_url"]).rstrip("/").rsplit("/", 1)[-1]
+        vehicle = await self.scwiki.get_vehicle(resolved_slug)
+        return {"source": self.scwiki.api_base_url, "vehicle": self._summarize_scwiki_vehicle(vehicle)}
+
     async def search_cornerstone_items(
         self,
         query: str = "",
@@ -1255,7 +1787,7 @@ class ToolRegistry:
             return {"error": "No Cornerstone item matched. Provide an id or a more specific query."}
 
         page = await self.cornerstone.get_item_page(str(item["id"]))
-        parsed = parse_cornerstone_item_page(page["html"])
+        parsed = parse_cornerstone_item_page(page["html"], page["url"])
         locations = parsed.get("locations") or []
         location_filter = (location or "").casefold().strip()
         if location_filter:
@@ -1280,22 +1812,132 @@ class ToolRegistry:
             "locations": locations[:limit],
         }
 
-    def _pending(self, label: str, endpoint: str, payload: dict[str, Any], method: str = "POST") -> dict[str, Any]:
+    async def get_cornerstone_item_media(
+        self,
+        id: str | None = None,
+        query: str | None = None,
+        limit: int = 5,
+    ) -> dict[str, Any]:
+        item = await self._resolve_cornerstone_item(id=id, query=query)
+        if not item:
+            return {"error": "No Cornerstone item matched. Provide an id or a more specific query."}
+
+        page = await self.cornerstone.get_item_page(str(item["id"]))
+        parsed = parse_cornerstone_item_page(page["html"], page["url"])
+        media = parsed.get("media") or []
+        limit = max(1, min(limit, 10))
+        return {
+            "source": self.cornerstone.base_url,
+            "url": page["url"],
+            "item": {
+                "id": item.get("id"),
+                "name": parsed.get("name") or item.get("name"),
+                "sold": bool(item.get("sold")),
+                "general": parsed.get("general") or {},
+            },
+            "returned": min(len(media), limit),
+            "truncated": len(media) > limit,
+            "media": media[:limit],
+        }
+
+    def _pending(
+        self,
+        label: str,
+        endpoint: str,
+        payload: dict[str, Any],
+        method: str = "POST",
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         action_id = str(uuid.uuid4())
         payload = {key: value for key, value in payload.items() if value is not None}
+        metadata = {key: value for key, value in (metadata or {}).items() if value is not None}
         payload = self._production_payload(endpoint, payload)
-        self.pending_actions[action_id] = PendingAction(action_id, label, endpoint, payload, method)
+        self.pending_actions[action_id] = PendingAction(action_id, label, endpoint, payload, method, metadata)
         return {
             "pending_action": {
                 "id": action_id,
                 "label": label,
                 "method": method,
                 "endpoint": endpoint,
-                "payload": payload,
+                "payload": self._display_payload(payload),
+                "metadata": metadata,
                 "approval_required": self.require_write_approval,
             }
         }
 
+    @staticmethod
+    def _display_payload(payload: dict[str, Any]) -> dict[str, Any]:
+        display = dict(payload)
+        image_data = display.get("image_data")
+        if isinstance(image_data, str) and image_data:
+            display["image_data"] = f"<base64 image data redacted; {len(image_data)} characters>"
+        return display
+
+    def _attach_chat_image(self, payload: dict[str, Any]) -> dict[str, Any]:
+        attached_index = payload.pop("attached_image_index", None)
+        use_attached_image = bool(payload.pop("use_attached_image", False) or attached_index is not None)
+        if payload.get("image_data") or not use_attached_image:
+            return {}
+        image = self._chat_image(attached_index or 0)
+        if not image:
+            return {"error": "No pasted chat image is available at the requested attached_image_index."}
+        payload["image_data"] = image["image_data"]
+        return {
+            "metadata": {
+                "attached_chat_image_name": image.get("name"),
+                "attached_chat_image_content_type": image.get("content_type"),
+                "attached_chat_image_index": attached_index or 0,
+                "attached_chat_image_status": "included",
+            }
+        }
+
+    def _chat_image(self, index: int) -> dict[str, Any] | None:
+        images = self._chat_images_var.get()
+        if 0 <= index < len(images):
+            return images[index]
+        return None
+
+    @staticmethod
+    def _normalize_chat_images(images: list[dict[str, Any]] | None) -> list[dict[str, Any]]:
+        normalized: list[dict[str, Any]] = []
+        for image in images or []:
+            if not isinstance(image, dict):
+                continue
+            image_data = str(image.get("image_data") or "").strip()
+            if not image_data:
+                continue
+            normalized.append(
+                {
+                    "name": str(image.get("name") or "").strip() or "pasted-image.png",
+                    "content_type": str(image.get("content_type") or "image/png").strip() or "image/png",
+                    "image_data": image_data,
+                }
+            )
+        return normalized
+
+    @staticmethod
+    def _int_or_none(value: Any) -> int | None:
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return None
+
+    def _record_pending_action_result(self, action: PendingAction, result_kind: str, result: dict[str, Any]) -> None:
+        metadata = action.metadata or {}
+        plan_id = metadata.get("plan_id")
+        if not plan_id or self.plan_store is None:
+            return
+        message = f"{action.label} {result_kind} for continual plan."
+        event_metadata = {"action_id": action.id, "endpoint": action.endpoint, "payload": action.payload, "result": result, **metadata}
+        self.plan_store.add_event(plan_id, result_kind, message, event_metadata)
+        if result_kind == "approved" and action.endpoint == "marketplace_negotiations_messages":
+            self.plan_store.add_negotiation(
+                plan_id,
+                metadata.get("plan_item_id"),
+                metadata.get("candidate_id"),
+                {**metadata, "status": "approved"},
+            )
+
     @staticmethod
     def _production_payload(endpoint: str, payload: dict[str, Any]) -> dict[str, Any]:
         if endpoint not in UEX_PRODUCTION_WRITE_RESOURCES:
@@ -1773,6 +2415,83 @@ class ToolRegistry:
             "expires_at": listing.get("date_expiration"),
         }
 
+    @staticmethod
+    def _summarize_marketplace_trend(trend: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "id_item": trend.get("id_item"),
+            "item_name": trend.get("item_name"),
+            "item_slug": trend.get("item_slug"),
+            "currency": trend.get("currency"),
+            "sell": {
+                "avg_price": trend.get("price_avg_sell"),
+                "avg_price_month": trend.get("price_avg_month_sell"),
+                "min_price": trend.get("price_min_sell"),
+                "max_price": trend.get("price_max_sell"),
+                "listings_count": trend.get("listings_count_sell"),
+            },
+            "buy": {
+                "avg_price": trend.get("price_avg_buy"),
+                "avg_price_month": trend.get("price_avg_month_buy"),
+                "min_price": trend.get("price_min_buy"),
+                "max_price": trend.get("price_max_buy"),
+                "listings_count": trend.get("listings_count_buy"),
+            },
+            "total_listings_count": trend.get("total_listings_count"),
+            "negotiations_count": trend.get("negotiations_count"),
+            "negotiations_open": trend.get("negotiations_open"),
+            "negotiations_success": trend.get("negotiations_success"),
+            "link_prices": trend.get("link_prices"),
+            "link_prices_history": trend.get("link_prices_history"),
+        }
+
+    @staticmethod
+    def _summarize_scwiki_vehicle_search(vehicle: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "name": vehicle.get("name"),
+            "class_name": vehicle.get("class_name"),
+            "career": vehicle.get("extra_label"),
+            "api_url": vehicle.get("api_url"),
+            "web_url": vehicle.get("web_url"),
+        }
+
+    @staticmethod
+    def _summarize_scwiki_vehicle(vehicle: dict[str, Any]) -> dict[str, Any]:
+        purchases = []
+        for entry in ((vehicle.get("uex_prices") or {}).get("purchase") or []):
+            if not isinstance(entry, dict):
+                continue
+            location = entry.get("starmap_location") or {}
+            purchases.append(
+                {
+                    "price_buy": entry.get("price_buy"),
+                    "terminal_name": entry.get("terminal_name"),
+                    "location": location.get("name"),
+                    "parent_location": location.get("parent_name"),
+                    "star_system": location.get("star_system_name"),
+                    "game_version": entry.get("game_version"),
+                    "date_updated": entry.get("date_updated"),
+                    "uex_link": entry.get("uex_link"),
+                }
+            )
+        return {
+            "name": vehicle.get("name") or vehicle.get("game_name"),
+            "game_name": vehicle.get("game_name"),
+            "slug": vehicle.get("slug"),
+            "manufacturer": (vehicle.get("manufacturer") or {}).get("name"),
+            "career": vehicle.get("career"),
+            "role": vehicle.get("role"),
+            "size_class": vehicle.get("size_class"),
+            "cargo_capacity": vehicle.get("cargo_capacity"),
+            "crew": vehicle.get("crew"),
+            "msrp": vehicle.get("msrp"),
+            "pledge_url": vehicle.get("pledge_url"),
+            "purchase_locations": purchases,
+            "description": ((vehicle.get("description") or {}).get("en_EN") or (vehicle.get("game_description") or {}).get("en_EN")),
+            "web_url": vehicle.get("web_url"),
+            "updated_at": vehicle.get("updated_at"),
+            "version": vehicle.get("version"),
+        }
+
     @classmethod
     def _summarize_negotiation(cls, negotiation: dict[str, Any]) -> dict[str, Any]:
         summary = cls._project_item(negotiation, mode="summary")

traderai/version.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.0.3"
+__version__ = "0.0.6"
 
 RELEASES_URL = "https://git.hudsonriggs.systems/LambdaBankingConglomerate/TraderAI/releases"
 RELEASES_API_URL = "https://git.hudsonriggs.systems/api/v1/repos/LambdaBankingConglomerate/TraderAI/releases"
@@ -9,3 +9,7 @@ RELEASES_API_URL = "https://git.hudsonriggs.systems/api/v1/repos/LambdaBankingCo
 
 
 
+
+
+
+

uv.lock

@@ -755,7 +755,7 @@ wheels = [
 
 [[package]]
 name = "traderai"
-version = "0.0.3"
+version = "0.0.6"
 source = { virtual = "." }
 dependencies = [
     { name = "apscheduler" },
@@ -1049,3 +1049,7 @@ wheels = [
 
 
 
+
+
+
+

web/app.js

@@ -1,5 +1,6 @@
 const form = document.getElementById("chat-form");
 const input = document.getElementById("message-input");
+const composerImagesEl = document.getElementById("composer-images");
 const messages = document.getElementById("messages");
 const statusEl = document.getElementById("status");
 const pendingEl = document.getElementById("pending-actions");
@@ -13,9 +14,11 @@ const configStatusEl = document.getElementById("config-status");
 const configPathsEl = document.getElementById("config-paths");
 const settingsToggle = document.getElementById("settings-toggle");
 const memoryToggle = document.getElementById("memory-toggle");
+const plansToggle = document.getElementById("plans-toggle");
 const ollamaToggle = document.getElementById("ollama-toggle");
 const settingsPanel = document.getElementById("settings-panel");
 const memoryPanel = document.getElementById("memory-panel");
+const plansPanel = document.getElementById("plans-panel");
 const ollamaPanel = document.getElementById("ollama-panel");
 const ollamaForm = document.getElementById("ollama-config-form");
 const ollamaRefreshButton = document.getElementById("ollama-refresh");
@@ -23,6 +26,10 @@ const ollamaDownloadButton = document.getElementById("ollama-download");
 const ollamaInstallButton = document.getElementById("ollama-install");
 const ollamaLaunchButton = document.getElementById("ollama-launch");
 const ollamaPullButton = document.getElementById("ollama-pull");
+const codexLoginButton = document.getElementById("codex-login");
+const openaiModelsRefreshButton = document.getElementById("openai-models-refresh");
+const providerModelSelect = document.getElementById("provider-model-select");
+const modelReasoningEffortSelect = document.getElementById("model-reasoning-effort");
 const ollamaStatusEl = document.getElementById("ollama-status");
 const ollamaMessageEl = document.getElementById("ollama-message");
 const updateCheckButton = document.getElementById("update-check");
@@ -47,31 +54,66 @@ const updateModalCopy = document.getElementById("update-modal-copy");
 const updateModalClose = document.getElementById("update-modal-close");
 const updateModalInstall = document.getElementById("update-modal-install");
 const updateModalReleases = document.getElementById("update-modal-releases");
+const plansRefreshButton = document.getElementById("plans-refresh");
+const plansCloseButton = document.getElementById("plans-close");
+const planForm = document.getElementById("plan-form");
+const plansStatusEl = document.getElementById("plans-status");
+const plansDashboardEl = document.getElementById("plans-dashboard");
+const plansRailListEl = document.getElementById("plans-rail-list");
+const providerScopedFields = Array.from(document.querySelectorAll("[data-provider-scope]"));
 
 let ollamaOnline = true;
 let latestUpdate = null;
 let currentThreadId = "default";
 let currentNegotiationId = null;
 let latestOllamaStatus = null;
+let composerImages = [];
 const clickedOllamaActions = new Set();
 
 if (window.lucide) {
   window.lucide.createIcons();
 }
 
-function addMessage(role, text) {
+function addMessage(role, text, options = {}) {
   const node = document.createElement("div");
   node.className = `message ${role}`;
-  setMessageMarkdown(node, text);
+  setMessageMarkdown(node, text, options);
   messages.appendChild(node);
   messages.scrollTop = messages.scrollHeight;
   return node;
 }
 
-function setMessageMarkdown(node, text) {
+function setMessageMarkdown(node, text, options = {}) {
   const body = node.querySelector(".message-body") || node;
-  body.innerHTML = renderMarkdown(text);
+  body.innerHTML = "";
-  enhanceNegotiationLinks(body);
+  const attachedImages = options.images || [];
+  if (attachedImages.length) {
+    body.appendChild(renderImageGallery(attachedImages));
+  }
+  if (text) {
+    const markdown = document.createElement("div");
+    markdown.innerHTML = renderMarkdown(text);
+    body.appendChild(markdown);
+    enhanceNegotiationLinks(markdown);
+  }
+}
+
+function renderImageGallery(images) {
+  const gallery = document.createElement("div");
+  gallery.className = "message-images";
+  for (const image of images) {
+    const card = document.createElement("div");
+    card.className = "message-image";
+    const preview = document.createElement("img");
+    preview.src = image.preview_url || `data:${image.content_type || "image/png"};base64,${image.image_data}`;
+    preview.alt = image.name || "Attached image";
+    const label = document.createElement("span");
+    label.className = "message-image-label";
+    label.textContent = image.name || "Attached image";
+    card.append(preview, label);
+    gallery.appendChild(card);
+  }
+  return gallery;
 }
 
 function setMessageActivity(node, text, active = false) {
@@ -451,6 +493,74 @@ function escapeHtml(text) {
     .replace(/'/g, "'");
 }
 
+function composerImageId() {
+  if (window.crypto?.randomUUID) return window.crypto.randomUUID();
+  return `image-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function readFileAsDataUrl(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result || ""));
+    reader.onerror = () => reject(reader.error || new Error(`Could not read ${file.name || "image"}`));
+    reader.readAsDataURL(file);
+  });
+}
+
+async function addComposerImages(files) {
+  const additions = [];
+  for (const file of files) {
+    if (!file || !String(file.type || "").startsWith("image/")) continue;
+    const previewUrl = await readFileAsDataUrl(file);
+    const [, imageData = ""] = previewUrl.split(",", 2);
+    if (!imageData) continue;
+    additions.push({
+      id: composerImageId(),
+      name: file.name || `pasted-image-${composerImages.length + additions.length + 1}.png`,
+      content_type: file.type || "image/png",
+      image_data: imageData,
+      preview_url: previewUrl,
+    });
+  }
+  if (!additions.length) return;
+  composerImages = [...composerImages, ...additions];
+  renderComposerImages();
+}
+
+function removeComposerImage(imageId) {
+  composerImages = composerImages.filter((image) => image.id !== imageId);
+  renderComposerImages();
+}
+
+function clearComposerImages() {
+  composerImages = [];
+  renderComposerImages();
+}
+
+function renderComposerImages() {
+  if (!composerImagesEl) return;
+  composerImagesEl.innerHTML = "";
+  composerImagesEl.hidden = !composerImages.length;
+  for (const image of composerImages) {
+    const card = document.createElement("div");
+    card.className = "composer-image";
+    const preview = document.createElement("img");
+    preview.src = image.preview_url;
+    preview.alt = image.name || "Pasted image";
+    const remove = document.createElement("button");
+    remove.type = "button";
+    remove.className = "composer-image-remove";
+    remove.textContent = "×";
+    remove.title = "Remove image";
+    remove.addEventListener("click", () => removeComposerImage(image.id));
+    const label = document.createElement("span");
+    label.className = "composer-image-name";
+    label.textContent = image.name || "Pasted image";
+    card.append(preview, remove, label);
+    composerImagesEl.appendChild(card);
+  }
+}
+
 function formatMetrics(event) {
   const read = formatTokenMetric(event.reading_tokens, event.reading_tokens_per_second);
   const wrote = formatTokenMetric(event.writing_tokens, event.writing_tokens_per_second);
@@ -486,9 +596,16 @@ const configFieldIds = {
 };
 
 const ollamaFieldIds = {
+  model_provider: "model-provider",
   ollama_base_url: "ollama-base-url",
   ollama_model: "ollama-model",
   ollama_num_ctx: "ollama-num-ctx",
+  openai_base_url: "openai-base-url",
+  openai_api_key: "openai-api-key",
+  openai_model: "openai-model",
+  model_reasoning_effort: "model-reasoning-effort",
+  codex_command: "codex-command",
+  codex_model: "codex-model",
 };
 
 async function refreshConfig() {
@@ -519,8 +636,15 @@ function renderConfig(config) {
   for (const [key, id] of Object.entries(ollamaFieldIds)) {
     const field = document.getElementById(id);
     if (!field) continue;
-    field.value = values[key] ?? "";
+    if (field.type === "password") {
+      field.value = "";
+      field.placeholder = secretsConfigured[key] ? "Configured" : "";
+    } else {
+      field.value = values[key] ?? "";
+    }
   }
+  renderReasoningEffortOptions(["none", "minimal", "low", "medium", "high", "xhigh"], values.model_reasoning_effort || "medium");
+  updateProviderFieldVisibility(values.model_provider || "ollama");
   configPathsEl.textContent = `App data: ${config.app_data_dir}\nConfig: ${config.config_path}\nLog: ${config.log_path}\nEdge profile: ${config.edge_profile_dir}`;
   configStatusEl.textContent = "";
 }
@@ -557,7 +681,7 @@ async function saveOllamaConfig(event) {
     if (!field) continue;
     values[key] = field.value;
   }
-  setOllamaMessage("Saving Ollama config");
+  setOllamaMessage("Saving provider config");
   try {
     const response = await fetch("/api/config", {
       method: "POST",
@@ -569,46 +693,79 @@ async function saveOllamaConfig(event) {
     setOllamaMessage(result.message || "Saved");
     await refreshOllamaStatus();
   } catch (error) {
-    setOllamaMessage(`Ollama config save failed: ${fetchErrorMessage(error)}`);
+    setOllamaMessage(`Provider config save failed: ${fetchErrorMessage(error)}`);
   }
 }
 
 async function refreshOllamaStatus() {
   if (!ollamaStatusEl) return;
-  ollamaStatusEl.textContent = "Checking Ollama";
+  ollamaStatusEl.textContent = "Checking provider";
   try {
     const response = await fetch("/api/ollama/status");
     const status = await response.json();
     renderOllamaStatus(status);
   } catch (error) {
-    ollamaStatusEl.textContent = `Ollama status failed: ${error.message}`;
+    ollamaStatusEl.textContent = `Provider status failed: ${error.message}`;
   }
 }
 
 function renderOllamaStatus(status) {
   if (!ollamaStatusEl) return;
   latestOllamaStatus = status;
+  updateProviderFieldVisibility(status.provider || "ollama");
+  const provider = providerDisplayName(status.provider);
   const models = status.models?.length ? status.models.join(", ") : "None detected";
-  const pillClass = status.installed && status.running && status.model_available ? "status-pill" : "status-pill warning";
+  const isOpenAIProvider = status.provider === "openai";
+  const isCodexProvider = status.provider === "codex";
+  const ready = isOpenAIProvider
+    ? Boolean(status.online && status.model_available)
+    : Boolean(status.installed && status.running && status.model_available);
+  const pillClass = ready ? "status-pill" : "status-pill warning";
+  const detailItems = [
+    ollamaStatusItem("Provider", provider),
+    ollamaStatusItem("Model", status.configured_model || ""),
+    ollamaStatusItem(isCodexProvider ? "Command" : "URL", status.base_url || ""),
+  ];
+  if (!isOpenAIProvider && !isCodexProvider) {
+    detailItems.splice(1, 0, ollamaStatusItem("Installed", status.installed ? "Yes" : "No"));
+    detailItems.splice(2, 0, ollamaStatusItem("Running", status.running ? "Yes" : "No"));
+    detailItems.push(ollamaStatusItem("Pulled", status.model_available ? "Yes" : "No"));
+    if (status.can_auto_install) detailItems.push(ollamaStatusItem("Auto Install", "Available"));
+    if (status.num_ctx) detailItems.push(ollamaStatusItem("Context", status.num_ctx));
+  } else {
+    detailItems.splice(1, 0, ollamaStatusItem("Connected", status.online ? "Yes" : "No"));
+  }
   ollamaStatusEl.innerHTML = `
     <div class="${pillClass}">${escapeHtml(status.message || "Unknown")}</div>
     <div class="ollama-status-grid">
-      ${ollamaStatusItem("Installed", status.installed ? "Yes" : "No")}
+      ${detailItems.join("")}
-      ${ollamaStatusItem("Running", status.running ? "Yes" : "No")}
-      ${ollamaStatusItem("Model", status.configured_model || "")}
-      ${ollamaStatusItem("Pulled", status.model_available ? "Yes" : "No")}
-      ${ollamaStatusItem("URL", status.base_url || "")}
-      ${status.can_auto_install ? ollamaStatusItem("Auto Install", "Available") : ""}
     </div>
-    ${ollamaStatusItem("Installed Models", models)}
+    ${ollamaStatusItem(isOpenAIProvider || isCodexProvider ? "Available Models" : "Installed Models", models)}
     ${status.detail ? ollamaStatusItem("Detail", status.detail) : ""}
   `;
+  if (ollamaDownloadButton) ollamaDownloadButton.hidden = isOpenAIProvider || isCodexProvider;
   if (ollamaInstallButton) {
-    ollamaInstallButton.hidden = !status.can_auto_install;
+    ollamaInstallButton.hidden = isOpenAIProvider || isCodexProvider || !status.can_auto_install;
     ollamaInstallButton.disabled = Boolean(status.installed) || !status.can_auto_install;
   }
-  if (ollamaLaunchButton) ollamaLaunchButton.disabled = !status.installed || Boolean(status.running);
+  if (ollamaLaunchButton) {
-  if (ollamaPullButton) ollamaPullButton.disabled = !status.running || Boolean(status.model_available);
+    ollamaLaunchButton.hidden = isOpenAIProvider || isCodexProvider;
+    ollamaLaunchButton.disabled = !status.installed || Boolean(status.running);
+  }
+  if (ollamaPullButton) {
+    ollamaPullButton.hidden = isOpenAIProvider || isCodexProvider;
+    ollamaPullButton.disabled = !status.running || Boolean(status.model_available);
+  }
+  if (codexLoginButton) {
+    codexLoginButton.hidden = !isCodexProvider;
+    codexLoginButton.disabled = Boolean(status.online);
+  }
+  if (openaiModelsRefreshButton) {
+    openaiModelsRefreshButton.hidden = false;
+    openaiModelsRefreshButton.disabled = false;
+  }
+  renderProviderModelOptions(status.models || [], status);
+  renderReasoningEffortOptions(status.reasoning_efforts || [], status.configured_reasoning_effort || "medium");
   updateOllamaAttention(status);
 }
 
@@ -651,12 +808,18 @@ function setOllamaButtonAttention(button, action, active) {
 function updateOllamaAttention(status = null) {
   const currentStatus = status || latestOllamaStatus;
   if (!currentStatus) return;
-  const ready = Boolean(currentStatus.installed && currentStatus.running && currentStatus.model_available);
+  const isOpenAIProvider = currentStatus.provider === "openai";
+  const isCodexProvider = currentStatus.provider === "codex";
+  const ready = isOpenAIProvider
+    ? Boolean(currentStatus.online && currentStatus.model_available)
+    : Boolean(currentStatus.installed && currentStatus.running && currentStatus.model_available);
   ollamaToggle?.classList.toggle("attention-pulse", !ready);
-  setOllamaButtonAttention(ollamaDownloadButton, "download", !currentStatus.installed);
+  setOllamaButtonAttention(ollamaDownloadButton, "download", !isOpenAIProvider && !isCodexProvider && !currentStatus.installed);
-  setOllamaButtonAttention(ollamaInstallButton, "install", !currentStatus.installed && currentStatus.can_auto_install);
+  setOllamaButtonAttention(ollamaInstallButton, "install", !isOpenAIProvider && !isCodexProvider && !currentStatus.installed && currentStatus.can_auto_install);
-  setOllamaButtonAttention(ollamaLaunchButton, "launch", currentStatus.installed && !currentStatus.running);
+  setOllamaButtonAttention(ollamaLaunchButton, "launch", !isOpenAIProvider && !isCodexProvider && currentStatus.installed && !currentStatus.running);
-  setOllamaButtonAttention(ollamaPullButton, "pull", currentStatus.running && !currentStatus.model_available);
+  setOllamaButtonAttention(ollamaPullButton, "pull", !isOpenAIProvider && !isCodexProvider && currentStatus.running && !currentStatus.model_available);
+  setOllamaButtonAttention(codexLoginButton, "codex-login", isCodexProvider && !currentStatus.online);
+  setOllamaButtonAttention(openaiModelsRefreshButton, "openai-models", isOpenAIProvider && !currentStatus.model_available);
   if (ready) clickedOllamaActions.clear();
 }
 
@@ -664,6 +827,137 @@ function configuredOllamaModel() {
   return document.getElementById("ollama-model")?.value || "";
 }
 
+function updateProviderFieldVisibility(provider) {
+  for (const field of providerScopedFields) {
+    const scope = field.dataset.providerScope;
+    field.hidden = scope !== provider;
+  }
+}
+
+function renderProviderModelOptions(models, status = latestOllamaStatus) {
+  const datalist = document.getElementById("provider-models");
+  if (datalist) datalist.innerHTML = "";
+  for (const model of models) {
+    if (datalist) {
+      const option = document.createElement("option");
+      option.value = model;
+      datalist.appendChild(option);
+    }
+  }
+  if (!providerModelSelect) return;
+  const provider = status?.provider || document.getElementById("model-provider")?.value || "ollama";
+  const configuredModel = configuredProviderModel(provider);
+  providerModelSelect.innerHTML = "";
+  const allModels = [...new Set([configuredModel, ...models].filter(Boolean))];
+  if (!allModels.length) {
+    const option = document.createElement("option");
+    option.value = "";
+    option.textContent = "No models detected";
+    providerModelSelect.appendChild(option);
+    providerModelSelect.disabled = true;
+    return;
+  }
+  providerModelSelect.disabled = false;
+  for (const model of allModels) {
+    const option = document.createElement("option");
+    option.value = model;
+    option.textContent = model;
+    if (model === configuredModel) option.selected = true;
+    providerModelSelect.appendChild(option);
+  }
+}
+
+async function refreshOpenAIModels() {
+  setOllamaMessage("Loading provider models");
+  try {
+    const provider = document.getElementById("model-provider")?.value || latestOllamaStatus?.provider || "openai";
+    const response = await fetch(`/api/provider/models?provider=${encodeURIComponent(provider)}`);
+    const result = await response.json();
+    if (!response.ok) throw new Error(result.detail || `HTTP ${response.status}`);
+    renderProviderModelOptions(result.models || [], {
+      provider: result.provider || provider,
+      configured_model: configuredProviderModel(result.provider || provider),
+    });
+    setOllamaMessage(result.message || "Loaded provider models");
+    await refreshOllamaStatus();
+  } catch (error) {
+    setOllamaMessage(`Provider model load failed: ${fetchErrorMessage(error)}`);
+  }
+}
+
+async function launchCodexLogin() {
+  markOllamaActionClicked("codex-login");
+  setOllamaMessage("Starting Codex sign-in");
+  try {
+    const response = await fetch("/api/codex/login", { method: "POST" });
+    const result = await response.json();
+    if (!response.ok) throw new Error(result.detail || `HTTP ${response.status}`);
+    if (result.auth_url) {
+      window.open(result.auth_url, "_blank", "noopener,noreferrer");
+    }
+    setOllamaMessage(result.message || "Opened Codex sign-in in your browser. Waiting for completion...");
+    await waitForCodexLogin();
+  } catch (error) {
+    setOllamaMessage(`Codex sign-in failed: ${fetchErrorMessage(error)}`);
+  }
+}
+
+async function waitForCodexLogin() {
+  for (let attempt = 0; attempt < 80; attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, attempt < 8 ? 1500 : 3000));
+    await refreshOllamaStatus();
+    const provider = latestOllamaStatus?.provider || "";
+    if (provider === "codex" && latestOllamaStatus?.online) {
+      setOllamaMessage("Codex sign-in complete.");
+      return;
+    }
+  }
+  setOllamaMessage("Codex sign-in opened. If you completed it, click Load Provider Models or refresh provider status.");
+}
+
+function renderReasoningEffortOptions(efforts, configured) {
+  if (!modelReasoningEffortSelect) return;
+  const options = [...new Set([...(efforts || []), configured || "medium"].filter(Boolean))];
+  modelReasoningEffortSelect.innerHTML = "";
+  for (const effort of options) {
+    const option = document.createElement("option");
+    option.value = effort;
+    option.textContent = effort;
+    if (effort === configured) option.selected = true;
+    modelReasoningEffortSelect.appendChild(option);
+  }
+}
+
+function configuredProviderModel(provider) {
+  if (provider === "openai") return document.getElementById("openai-model")?.value || "";
+  if (provider === "codex") return document.getElementById("codex-model")?.value || "";
+  return document.getElementById("ollama-model")?.value || "";
+}
+
+function syncSelectedProviderModel() {
+  const provider = document.getElementById("model-provider")?.value || "ollama";
+  const selectedModel = providerModelSelect?.value || "";
+  if (!selectedModel) return;
+  if (provider === "openai") {
+    const field = document.getElementById("openai-model");
+    if (field) field.value = selectedModel;
+    return;
+  }
+  if (provider === "codex") {
+    const field = document.getElementById("codex-model");
+    if (field) field.value = selectedModel;
+    return;
+  }
+  const field = document.getElementById("ollama-model");
+  if (field) field.value = selectedModel;
+}
+
+function providerDisplayName(provider) {
+  if (provider === "openai") return "OpenAI";
+  if (provider === "codex") return "Codex";
+  return "Local Ollama";
+}
+
 async function checkForUpdate(promptUser = false) {
   if (!updateStatusEl) return;
   updateStatusEl.textContent = "Checking releases";
@@ -963,6 +1257,19 @@ function closeNegotiationPanel() {
   negotiationStatusEl.textContent = "";
 }
 
+function openPlansPanel(openPlanId = null) {
+  if (!plansPanel) return;
+  plansPanel.hidden = false;
+  plansToggle?.setAttribute("aria-expanded", "true");
+  refreshPlans(openPlanId);
+}
+
+function closePlansPanel() {
+  if (!plansPanel) return;
+  plansPanel.hidden = true;
+  plansToggle?.setAttribute("aria-expanded", "false");
+}
+
 function renderNegotiationMessages(data) {
   negotiationMessagesEl.innerHTML = "";
   const items = Array.isArray(data) ? data : [data].filter(Boolean);
@@ -1002,20 +1309,373 @@ async function submitNegotiationMessage(event) {
   }
 }
 
+function parsePlanItems(text) {
+  return text
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const [name, quantity, maxPrice] = line.split("|").map((part) => part.trim());
+      const item = { item_name: name };
+      if (quantity) item.desired_quantity = Math.max(1, Number.parseInt(quantity, 10) || 1);
+      if (maxPrice) item.max_unit_price = Number(maxPrice.replace(/,/g, ""));
+      return item;
+    });
+}
+
+async function createPlan(event) {
+  event.preventDefault();
+  const title = document.getElementById("plan-title").value.trim();
+  const objective = document.getElementById("plan-objective").value.trim();
+  if (!title || !objective) return;
+  const tone = document.getElementById("plan-tone").value.trim();
+  const instructions = document.getElementById("plan-instructions").value.trim();
+  const constraints = {};
+  if (tone) constraints.message_tone = tone;
+  if (instructions) constraints.instructions = instructions;
+  const payload = {
+    title,
+    objective,
+    kind: document.getElementById("plan-kind").value || "buying",
+    cadence: document.getElementById("plan-cadence").value.trim() || null,
+    constraints,
+    items: parsePlanItems(document.getElementById("plan-items").value || ""),
+  };
+  plansStatusEl.textContent = "Creating plan";
+  try {
+    const response = await fetch("/api/plans", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    const result = await response.json();
+    if (!response.ok) throw new Error(result.detail || `HTTP ${response.status}`);
+    planForm.reset();
+    plansStatusEl.textContent = result.plan?.status === "needs_input"
+      ? "Plan created, but it needs an item checklist."
+      : "Plan created";
+    await refreshPlans(result.plan?.id);
+  } catch (error) {
+    plansStatusEl.textContent = `Plan create failed: ${fetchErrorMessage(error)}`;
+  }
+}
+
+async function refreshPlans(openPlanId = null) {
+  if (!plansDashboardEl && !plansRailListEl) return;
+  try {
+    const response = await fetch("/api/plans");
+    const result = await response.json();
+    const plans = result.plans || [];
+    renderPlansRail(plans);
+    if (plansDashboardEl) await renderPlans(plans, openPlanId);
+  } catch (error) {
+    if (plansDashboardEl) plansDashboardEl.textContent = `Plans failed: ${fetchErrorMessage(error)}`;
+    if (plansRailListEl) plansRailListEl.textContent = `Plans failed: ${fetchErrorMessage(error)}`;
+  }
+}
+
+function renderPlansRail(plans) {
+  if (!plansRailListEl) return;
+  plansRailListEl.innerHTML = "";
+  if (!plans.length) {
+    plansRailListEl.innerHTML = '<div class="pending-empty">No plans</div>';
+    return;
+  }
+  for (const plan of plans.slice(0, 5)) {
+    const row = document.createElement("button");
+    row.type = "button";
+    row.className = "plan-rail-item";
+    const title = document.createElement("span");
+    title.className = "plan-rail-title";
+    title.textContent = plan.title || "Untitled plan";
+    const status = document.createElement("span");
+    status.className = "plan-rail-status";
+    status.textContent = plan.status || "plan";
+    row.append(title, status);
+    row.addEventListener("click", () => openPlansPanel(plan.id));
+    plansRailListEl.appendChild(row);
+  }
+  if (plans.length > 5) {
+    const more = document.createElement("button");
+    more.type = "button";
+    more.className = "plan-rail-item";
+    more.textContent = `${plans.length - 5} more`;
+    more.addEventListener("click", () => openPlansPanel());
+    plansRailListEl.appendChild(more);
+  }
+}
+
+async function renderPlans(plans, openPlanId = null) {
+  plansDashboardEl.innerHTML = "";
+  if (!plans.length) {
+    plansDashboardEl.innerHTML = `
+      <section class="plans-overview">
+        <div>
+          <p class="eyebrow">Plan board</p>
+          <h3>No plans yet</h3>
+          <p class="plan-overview-copy">Create a buying watchlist or a custom follow-up routine to start tracking work over time.</p>
+        </div>
+      </section>
+      <div class="plan-empty-state">
+        <h4>Nothing is running</h4>
+        <p>Your continual plans will appear here with status, timing, and recent activity.</p>
+      </div>
+    `;
+    return;
+  }
+  const activeCount = plans.filter((plan) => plan.status === "active").length;
+  const attentionCount = plans.filter((plan) => plan.status === "needs_input" || plan.status === "paused").length;
+  const overview = document.createElement("section");
+  overview.className = "plans-overview";
+  overview.innerHTML = `
+    <div>
+      <p class="eyebrow">Plan board</p>
+      <h3>${plans.length} continual ${plans.length === 1 ? "plan" : "plans"}</h3>
+      <p class="plan-overview-copy">Monitor recurring work, keep candidate leads in view, and jump into details when something needs attention.</p>
+    </div>
+    <div class="plan-overview-stats">
+      <div class="plan-overview-stat">
+        <span class="plan-overview-stat-value">${activeCount}</span>
+        <span class="plan-overview-stat-label">active</span>
+      </div>
+      <div class="plan-overview-stat">
+        <span class="plan-overview-stat-value">${attentionCount}</span>
+        <span class="plan-overview-stat-label">needs eyes</span>
+      </div>
+    </div>
+  `;
+  plansDashboardEl.appendChild(overview);
+  for (const plan of plans) {
+    const card = document.createElement("article");
+    card.className = `plan-card plan-status-${slugifyPlanValue(plan.status)}${plan.status === "active" ? " active" : ""}`;
+    const heading = document.createElement("div");
+    heading.className = "plan-card-heading";
+    const title = document.createElement("h3");
+    title.textContent = plan.title || "Untitled plan";
+    const statusBadge = document.createElement("span");
+    statusBadge.className = `plan-status-badge plan-status-${slugifyPlanValue(plan.status)}`;
+    statusBadge.textContent = humanizePlanValue(plan.status || "unknown");
+    const meta = document.createElement("div");
+    meta.className = "plan-meta";
+    meta.textContent = plan.objective || "";
+    const pills = document.createElement("div");
+    pills.className = "plan-pill-row";
+    for (const value of [plan.kind, plan.next_run_at ? `next ${formatShortDate(plan.next_run_at)}` : "not scheduled"]) {
+      const pill = document.createElement("span");
+      pill.className = "plan-pill";
+      pill.textContent = humanizePlanValue(value);
+      pills.appendChild(pill);
+    }
+    const metrics = document.createElement("div");
+    metrics.className = "plan-metrics";
+    metrics.append(
+      planMetric("Checklist", String((plan.items || []).length)),
+      planMetric("Cadence", summarizeCadence(plan.cadence)),
+      planMetric("Updated", formatShortDate(plan.updated_at || plan.created_at))
+    );
+    const controls = document.createElement("div");
+    controls.className = "plan-controls";
+    controls.append(
+      planButton("Details", () => loadPlanDetail(plan.id, card)),
+      planButton("Run", () => postPlanAction(plan.id, "run")),
+      planButton(plan.status === "active" ? "Pause" : "Resume", () => postPlanAction(plan.id, plan.status === "active" ? "pause" : "resume")),
+      planButton("Delete", () => deletePlan(plan.id), "secondary small-button")
+    );
+    heading.append(title, statusBadge);
+    card.append(heading, meta, pills, metrics, controls);
+    plansDashboardEl.appendChild(card);
+    if (openPlanId && plan.id === openPlanId) await loadPlanDetail(plan.id, card);
+  }
+}
+
+function planButton(label, onClick, className = "small-button") {
+  const button = document.createElement("button");
+  button.type = "button";
+  button.className = className;
+  button.textContent = label;
+  button.addEventListener("click", onClick);
+  return button;
+}
+
+async function loadPlanDetail(planId, card) {
+  const existing = card.querySelector(".plan-detail");
+  if (existing) {
+    existing.remove();
+    return;
+  }
+  const loading = document.createElement("div");
+  loading.className = "plan-detail plan-detail-loading";
+  loading.textContent = "Loading plan details...";
+  card.appendChild(loading);
+  const response = await fetch(`/api/plans/${encodeURIComponent(planId)}`);
+  const result = await response.json();
+  const plan = result.plan;
+  loading.remove();
+  const detail = document.createElement("div");
+  detail.className = "plan-detail";
+  detail.append(
+    planSection("Checklist", checklistLines(plan), "checklist"),
+    planSection("Best Candidates", bestCandidateLines(plan), "candidates"),
+    planSection("Recent Events", recentEventLines(plan), "events")
+  );
+  card.appendChild(detail);
+}
+
+function planSection(title, lines, sectionClass = "") {
+  const wrapper = document.createElement("section");
+  wrapper.className = `plan-section${sectionClass ? ` plan-section-${sectionClass}` : ""}`;
+  const heading = document.createElement("h4");
+  heading.textContent = title;
+  const list = document.createElement("ul");
+  list.className = "plan-list";
+  const items = lines.length ? lines : [planListItemData("Empty", "Nothing to show right now.")];
+  for (const line of items) {
+    const item = document.createElement("li");
+    if (typeof line === "string") {
+      item.textContent = line;
+    } else {
+      item.className = line.className || "";
+      const titleEl = document.createElement("div");
+      titleEl.className = "plan-list-title";
+      titleEl.textContent = line.title;
+      const bodyEl = document.createElement("div");
+      bodyEl.className = "plan-list-body";
+      bodyEl.textContent = line.body;
+      item.append(titleEl, bodyEl);
+    }
+    list.appendChild(item);
+  }
+  wrapper.append(heading, list);
+  return wrapper;
+}
+
+function planMetric(label, value) {
+  const metric = document.createElement("div");
+  metric.className = "plan-metric";
+  const metricLabel = document.createElement("span");
+  metricLabel.className = "plan-metric-label";
+  metricLabel.textContent = label;
+  const metricValue = document.createElement("span");
+  metricValue.className = "plan-metric-value";
+  metricValue.textContent = value;
+  metric.append(metricLabel, metricValue);
+  return metric;
+}
+
+function summarizeCadence(cadence) {
+  if (!cadence) return "manual";
+  return cadence.replace(/\s+/g, " ").trim();
+}
+
+function slugifyPlanValue(value) {
+  return String(value || "unknown")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/(^-|-$)/g, "");
+}
+
+function humanizePlanValue(value) {
+  return String(value || "")
+    .replace(/_/g, " ")
+    .replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+function planListItemData(title, body, className = "") {
+  return { title, body, className };
+}
+
+function checklistLines(plan) {
+  return (plan.items || []).map((item) => {
+    const quantity = `${item.acquired_quantity || 0}/${item.desired_quantity || 1}`;
+    const price = item.max_unit_price ? `Max ${Number(item.max_unit_price).toLocaleString()} UEC` : "No price cap";
+    return planListItemData(item.item_name, `${quantity} acquired • ${price} • ${humanizePlanValue(item.status || "pending")}`);
+  });
+}
+
+function bestCandidateLines(plan) {
+  const byItem = new Map((plan.items || []).map((item) => [item.id, item.item_name]));
+  return (plan.candidates || [])
+    .filter((candidate) => candidate.status === "current" || candidate.status === "drafted")
+    .slice(0, 6)
+    .map((candidate) => {
+      const title = byItem.get(candidate.plan_item_id) || "Item";
+      const listing = candidate.title || candidate.listing_slug || candidate.listing_id || "Unnamed listing";
+      const price = `${Number(candidate.price || 0).toLocaleString()} ${candidate.currency || "UEC"}`;
+      const seller = candidate.seller || "unknown seller";
+      return planListItemData(title, `${listing} • ${price} • ${seller} • ${humanizePlanValue(candidate.status || "current")}`);
+    });
+}
+
+function recentEventLines(plan) {
+  return (plan.events || [])
+    .slice(0, 5)
+    .map((event) => planListItemData(`${formatShortDate(event.created_at)} • ${humanizePlanValue(event.kind || "event")}`, event.message || "No details."));
+}
+
+async function postPlanAction(planId, action) {
+  plansStatusEl.textContent = `${action} requested`;
+  try {
+    const response = await fetch(`/api/plans/${encodeURIComponent(planId)}/${action}`, { method: "POST" });
+    const result = await response.json();
+    if (!response.ok) throw new Error(result.detail || `HTTP ${response.status}`);
+    plansStatusEl.textContent = result.summary || `Plan ${action} complete`;
+    await refreshPlans(planId);
+    await refreshPending();
+    await refreshInbox();
+  } catch (error) {
+    plansStatusEl.textContent = `Plan ${action} failed: ${fetchErrorMessage(error)}`;
+  }
+}
+
+async function deletePlan(planId) {
+  if (!window.confirm("Delete this plan and its stored history?")) return;
+  plansStatusEl.textContent = "delete requested";
+  try {
+    const response = await fetch(`/api/plans/${encodeURIComponent(planId)}`, { method: "DELETE" });
+    const result = await response.json();
+    if (!response.ok) throw new Error(result.detail || `HTTP ${response.status}`);
+    plansStatusEl.textContent = result.summary || "Plan deleted";
+    await refreshPlans();
+    await refreshPending();
+    await refreshInbox();
+  } catch (error) {
+    plansStatusEl.textContent = `Plan delete failed: ${fetchErrorMessage(error)}`;
+  }
+}
+
+function formatShortDate(value) {
+  if (!value) return "";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleString([], { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
+}
+
 async function checkHealth() {
   try {
-    const response = await fetch("/api/health");
+    let health = {};
-    const result = await response.json();
+    try {
-    const health = result.ollama || {};
+      const response = await fetch("/api/health");
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const result = await response.json();
+      health = result.inference || result.ollama || {};
+    } catch (primaryError) {
+      const fallbackResponse = await fetch("/api/ollama/status");
+      if (!fallbackResponse.ok) throw primaryError;
+      health = await fallbackResponse.json();
+    }
+    const provider = providerDisplayName(health.provider);
+    const isOpenAIProvider = health.provider === "openai";
+    const isCodexProvider = health.provider === "codex";
     ollamaOnline = Boolean(health.online);
     if (!ollamaOnline) {
       statusEl.textContent = "Offline";
-      setWarning("Ollama needs attention. Open the Ollama tab and use the pulsing action button.");
+      setWarning(`${provider} needs attention. Open the model provider tab and use the pulsing action button.`);
       ollamaToggle?.classList.add("attention-pulse");
       return false;
     }
     if (health.model_available === false) {
-      setWarning(`Ollama needs the configured model "${health.model}". Open the Ollama tab and use Install Model.`);
+      const action = isOpenAIProvider ? "Load Provider Models." : isCodexProvider ? "Sign In to Codex." : "Install Model.";
+      setWarning(`${provider} needs the configured model "${health.model}". Open the model provider tab and use ${action}`);
       ollamaToggle?.classList.add("attention-pulse");
     } else {
       setWarning("");
@@ -1026,7 +1686,7 @@ async function checkHealth() {
   } catch (error) {
     ollamaOnline = false;
     statusEl.textContent = "Offline";
-    setWarning("Could not check Ollama health. Open the Ollama tab and use the pulsing action button.");
+    setWarning("Could not check the active model provider. Open the model provider tab and use the pulsing action button.");
     ollamaToggle?.classList.add("attention-pulse");
     return false;
   }
@@ -1199,13 +1859,37 @@ input.addEventListener("keydown", async (event) => {
   }
 });
 
+input.addEventListener("paste", async (event) => {
+  const clipboardItems = [...(event.clipboardData?.items || [])];
+  const imageFiles = clipboardItems
+    .filter((item) => item.kind === "file" && String(item.type || "").startsWith("image/"))
+    .map((item) => item.getAsFile())
+    .filter(Boolean);
+  if (!imageFiles.length) return;
+  if (!event.clipboardData?.getData("text/plain")) {
+    event.preventDefault();
+  }
+  try {
+    await addComposerImages(imageFiles);
+  } catch (error) {
+    setWarning(`Image paste failed: ${fetchErrorMessage(error)}`);
+  }
+});
+
 memoryRefreshButton?.addEventListener("click", refreshMemory);
 memoryClearButton?.addEventListener("click", clearMemory);
 configRefreshButton?.addEventListener("click", refreshConfig);
 configForm?.addEventListener("submit", saveConfig);
 settingsToggle?.addEventListener("click", () => toggleSidebarPanel("settings"));
 memoryToggle?.addEventListener("click", () => toggleSidebarPanel("memory"));
+plansToggle?.addEventListener("click", () => {
+  if (plansPanel?.hidden) openPlansPanel();
+  else closePlansPanel();
+});
 ollamaToggle?.addEventListener("click", () => toggleSidebarPanel("ollama"));
+plansRefreshButton?.addEventListener("click", () => refreshPlans());
+plansCloseButton?.addEventListener("click", closePlansPanel);
+planForm?.addEventListener("submit", createPlan);
 ollamaForm?.addEventListener("submit", saveOllamaConfig);
 ollamaRefreshButton?.addEventListener("click", refreshOllamaStatus);
 ollamaDownloadButton?.addEventListener("click", () => {
@@ -1224,6 +1908,17 @@ ollamaPullButton?.addEventListener("click", () => {
   markOllamaActionClicked("pull");
   postOllamaAction("/api/ollama/pull", { body: { model: configuredOllamaModel() } });
 });
+codexLoginButton?.addEventListener("click", launchCodexLogin);
+providerModelSelect?.addEventListener("change", syncSelectedProviderModel);
+document.getElementById("model-provider")?.addEventListener("change", () => {
+  const provider = document.getElementById("model-provider")?.value || "ollama";
+  updateProviderFieldVisibility(provider);
+  renderProviderModelOptions(latestOllamaStatus?.models || [], { ...latestOllamaStatus, provider });
+});
+openaiModelsRefreshButton?.addEventListener("click", () => {
+  markOllamaActionClicked("openai-models");
+  refreshOpenAIModels();
+});
 updateCheckButton?.addEventListener("click", checkForUpdate);
 updateInstallButton?.addEventListener("click", installUpdate);
 updateOpenReleasesButton?.addEventListener("click", openReleasesPage);
@@ -1237,15 +1932,22 @@ updateModalInstall?.addEventListener("click", installUpdate);
 
 async function sendMessage() {
   const message = input.value.trim();
-  if (!message || input.disabled) return;
+  const attachedImages = composerImages.map(({ name, content_type, image_data, preview_url }) => ({
+    name,
+    content_type,
+    image_data,
+    preview_url,
+  }));
+  if ((!message && !attachedImages.length) || input.disabled) return;
   const healthy = await checkHealth();
   if (!healthy) {
-    addMessage("assistant warning-message", "Ollama needs attention before chat can continue. Open the Ollama tab and press the pulsing action button, then try again.");
+    addMessage("assistant warning-message", "The active model provider needs attention before chat can continue. Open the model provider tab and press the pulsing action button, then try again.");
     return;
   }
   input.value = "";
+  clearComposerImages();
   input.disabled = true;
-  addMessage("user", message);
+  addMessage("user", message, { images: attachedImages });
   const assistantNode = addMessage("assistant streaming", "");
   ensureStreamingChrome(assistantNode);
   let assistantText = "";
@@ -1257,7 +1959,7 @@ async function sendMessage() {
     const response = await fetch("/api/chat/stream", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ message, thread_id: currentThreadId }),
+      body: JSON.stringify({ message, thread_id: currentThreadId, images: attachedImages }),
     });
     if (!response.ok || !response.body) {
       throw new Error(`HTTP ${response.status}`);
@@ -1303,7 +2005,7 @@ async function sendMessage() {
     }
   } catch (error) {
     const message = error.message.includes("503")
-      ? "Ollama needs attention before chat can continue. Open the Ollama tab and press the pulsing action button, then try again."
+      ? "The active model provider needs attention before chat can continue. Open the model provider tab and press the pulsing action button, then try again."
       : `Chat failed: ${error.message}`;
     setWarning(message);
     setMessageMarkdown(assistantNode, message);
@@ -1320,6 +2022,7 @@ async function sendMessage() {
 
 refreshPending();
 refreshMemory();
+refreshPlans();
 refreshConfig();
 refreshOllamaStatus();
 refreshChats().then(() => loadChatMessages(currentThreadId));

web/index.html

@@ -9,7 +9,7 @@
   </head>
   <body>
     <main class="shell">
-      <nav class="chat-rail collapsed" id="chat-rail" aria-label="Chats and inbox">
+      <nav class="chat-rail collapsed" id="chat-rail" aria-label="Chats, plans, and inbox">
         <div class="chat-rail-top">
           <button class="icon-button" id="chat-sidebar-toggle" type="button" title="Chats" aria-expanded="false">
             <i data-lucide="panel-left" aria-hidden="true"></i>
@@ -25,6 +25,15 @@
             <div class="rail-heading">Chats</div>
             <div class="chat-list" id="chat-list"></div>
           </section>
+          <section class="chat-nav-section">
+            <div class="rail-heading-row">
+              <div class="rail-heading">Plans</div>
+              <button class="rail-icon-button" id="plans-toggle" type="button" title="Plans" aria-expanded="false" aria-controls="plans-panel">
+                <i data-lucide="list-checks" aria-hidden="true"></i>
+              </button>
+            </div>
+            <div class="plans-rail-list" id="plans-rail-list"></div>
+          </section>
           <section class="chat-nav-section">
             <div class="rail-heading">Inbox</div>
             <div class="inbox-list" id="inbox-list"></div>
@@ -42,17 +51,21 @@
               <h1>TraderAI</h1>
               <p>Institutional marketplace intelligence for UEX operations</p>
             </div>
+            <span class="brand-short" aria-hidden="true">LBC</span>
           </div>
           <div class="status" id="status">Ready</div>
         </header>
         <div class="warning" id="warning" hidden></div>
         <div class="messages" id="messages"></div>
-        <div class="composer-wrap">
+          <div class="composer-wrap">
-          <form class="composer" id="chat-form">
+            <form class="composer" id="chat-form">
-            <textarea id="message-input" rows="2" placeholder="Search listings, draft a reply, prepare an offer..."></textarea>
+              <div class="composer-main">
-            <button type="submit">Send</button>
+                <textarea id="message-input" rows="2" placeholder="Search listings, draft a reply, prepare an offer..."></textarea>
-          </form>
+                <div class="composer-images" id="composer-images" hidden></div>
-        </div>
+              </div>
+              <button type="submit">Send</button>
+            </form>
+          </div>
       </section>
       <aside class="actions">
         <section class="side-section">
@@ -60,21 +73,6 @@
           <div id="pending-actions" class="pending-empty">No pending actions</div>
         </section>
         <section class="side-section sidebar-tools">
-          <div class="sidebar-tool-buttons" role="tablist" aria-label="Sidebar panels">
-            <button class="sidebar-tool-button" id="settings-toggle" type="button" aria-expanded="false" aria-controls="settings-panel" title="Settings">
-              <i data-lucide="settings" aria-hidden="true"></i>
-              <span>Settings</span>
-            </button>
-            <button class="sidebar-tool-button" id="memory-toggle" type="button" aria-expanded="false" aria-controls="memory-panel" title="Memory">
-              <i data-lucide="brain" aria-hidden="true"></i>
-              <span>Memory</span>
-            </button>
-            <button class="sidebar-tool-button" id="ollama-toggle" type="button" aria-expanded="false" aria-controls="ollama-panel" title="Ollama">
-              <img class="sidebar-tool-image" src="/static/art/ollama-icon.svg" alt="" onerror="this.remove();">
-              <i data-lucide="bot" aria-hidden="true"></i>
-              <span>Ollama</span>
-            </button>
-          </div>
           <div class="sidebar-panel" id="settings-panel" hidden>
             <div class="section-title-row">
               <h2>Config</h2>
@@ -121,14 +119,29 @@
           </div>
           <div class="sidebar-panel" id="ollama-panel" hidden>
             <div class="section-title-row">
-              <h2>Ollama</h2>
+              <h2>Inference</h2>
               <button class="secondary small-button" id="ollama-refresh" type="button">Refresh</button>
             </div>
             <form class="config-form" id="ollama-config-form">
-              <label>Ollama URL<input id="ollama-base-url" name="ollama_base_url" type="text"></label>
+              <label>Provider
-              <label>Model<input id="ollama-model" name="ollama_model" type="text"></label>
+                <select id="model-provider" name="model_provider">
-              <label>Context Tokens<input id="ollama-num-ctx" name="ollama_num_ctx" type="number" min="1024" step="1024"></label>
+                  <option value="ollama">Local Ollama</option>
-              <button type="submit">Save Ollama Config</button>
+                  <option value="openai">OpenAI</option>
+                  <option value="codex">Codex</option>
+                </select>
+              </label>
+              <label data-provider-scope="ollama">Ollama URL<input id="ollama-base-url" name="ollama_base_url" type="text"></label>
+              <label data-provider-scope="ollama">Ollama Model<input id="ollama-model" name="ollama_model" type="text" list="provider-models"></label>
+              <label data-provider-scope="ollama">Context Tokens<input id="ollama-num-ctx" name="ollama_num_ctx" type="number" min="1024" step="1024"></label>
+              <label data-provider-scope="openai">OpenAI URL<input id="openai-base-url" name="openai_base_url" type="text"></label>
+              <label data-provider-scope="openai">OpenAI API Key<input id="openai-api-key" name="openai_api_key" type="password" autocomplete="off"></label>
+              <label data-provider-scope="openai">OpenAI Model<input id="openai-model" name="openai_model" type="text" list="provider-models"></label>
+              <label data-provider-scope="codex">Codex Command<input id="codex-command" name="codex_command" type="text"></label>
+              <label data-provider-scope="codex">Codex Model<input id="codex-model" name="codex_model" type="text" list="provider-models"></label>
+              <label>Available Models<select id="provider-model-select"></select></label>
+              <label>Reasoning Effort<select id="model-reasoning-effort" name="model_reasoning_effort"></select></label>
+              <datalist id="provider-models"></datalist>
+              <button type="submit">Save Provider Config</button>
             </form>
             <div class="ollama-status" id="ollama-status"></div>
             <div class="ollama-actions">
@@ -136,9 +149,26 @@
               <button class="secondary small-button" id="ollama-install" type="button">Auto Install</button>
               <button class="secondary small-button" id="ollama-launch" type="button">Launch</button>
               <button class="small-button" id="ollama-pull" type="button">Install Model</button>
+              <button class="secondary small-button" id="codex-login" type="button">Sign In to Codex</button>
+              <button class="secondary small-button" id="openai-models-refresh" type="button">Load Provider Models</button>
             </div>
             <div class="config-status" id="ollama-message"></div>
           </div>
+          <div class="sidebar-tool-buttons" role="tablist" aria-label="Sidebar panels">
+            <button class="sidebar-tool-button" id="settings-toggle" type="button" aria-expanded="false" aria-controls="settings-panel" title="Settings">
+              <i data-lucide="settings" aria-hidden="true"></i>
+              <span>Settings</span>
+            </button>
+            <button class="sidebar-tool-button" id="memory-toggle" type="button" aria-expanded="false" aria-controls="memory-panel" title="Memory">
+              <i data-lucide="brain" aria-hidden="true"></i>
+              <span>Memory</span>
+            </button>
+            <button class="sidebar-tool-button" id="ollama-toggle" type="button" aria-expanded="false" aria-controls="ollama-panel" title="Inference">
+              <img class="sidebar-tool-image" src="/static/art/ollama-icon.svg" alt="" onerror="this.remove();">
+              <i data-lucide="bot" aria-hidden="true"></i>
+              <span>Inference</span>
+            </button>
+          </div>
         </section>
       </aside>
     </main>
@@ -159,6 +189,60 @@
       </form>
       <div class="config-status" id="negotiation-status"></div>
     </div>
+    <div class="floating-panel plans-floating-panel" id="plans-panel" hidden>
+      <div class="floating-panel-header">
+        <div>
+          <p class="eyebrow">Continual work</p>
+          <h2>Plans</h2>
+        </div>
+        <div class="floating-panel-actions">
+          <button class="icon-button light" id="plans-refresh" type="button" title="Refresh plans">
+            <i data-lucide="refresh-cw" aria-hidden="true"></i>
+          </button>
+          <button class="icon-button light" id="plans-close" type="button" title="Close">
+            <i data-lucide="x" aria-hidden="true"></i>
+          </button>
+        </div>
+      </div>
+      <div class="plans-panel-body">
+        <aside class="plan-creator-shell">
+          <div class="plan-creator-card">
+            <div class="plan-creator-copy">
+              <p class="eyebrow">New continual plan</p>
+              <h3>Set the watch once</h3>
+              <p>Spin up buying runs or custom follow-up work with a title, a goal, and just enough guardrails to keep it on track.</p>
+            </div>
+            <form class="config-form plan-form-grid" id="plan-form">
+              <label>Title<input id="plan-title" type="text" placeholder="Wikelo Idris parts"></label>
+              <label>Objective<input id="plan-objective" type="text" placeholder="Find and draft deals for the parts I list"></label>
+              <div class="plan-form-split">
+                <label>Kind
+                  <select id="plan-kind">
+                    <option value="buying">Buying</option>
+                    <option value="custom">Custom</option>
+                  </select>
+                </label>
+                <label>Message Tone<input id="plan-tone" type="text" placeholder="polite and concise"></label>
+              </div>
+              <label>Items<textarea id="plan-items" rows="5" placeholder="One item per line, optionally: name | quantity | max unit price"></textarea></label>
+              <label>Instructions<textarea id="plan-instructions" rows="4" placeholder="Extra guidance for custom or buying plans"></textarea></label>
+              <div class="plan-form-split">
+                <label>Cron Cadence<input id="plan-cadence" type="text" placeholder="0 */6 * * *"></label>
+                <div class="plan-form-hint">
+                  <strong>Tip</strong>
+                  <span>Buying plans work best with item lines. Custom plans can run with just instructions.</span>
+                </div>
+              </div>
+              <button type="submit">Create Plan</button>
+              <div class="config-status" id="plans-status"></div>
+            </form>
+          </div>
+        </aside>
+        <section class="plans-dashboard-shell">
+          <div class="plans-dashboard" id="plans-dashboard"></div>
+        </section>
+      </div>
+    </div>
     <div class="modal-backdrop" id="update-modal" hidden>
       <section class="update-modal-card">
         <div class="section-title-row">

web/styles.css

@@ -105,7 +105,7 @@ body::before {
 
 .chat-rail-content {
   display: grid;
-  grid-template-rows: minmax(0, 1fr) minmax(140px, 34%);
+  grid-template-rows: minmax(0, 1fr) minmax(92px, 20%) minmax(130px, 30%);
   gap: 16px;
   min-height: 0;
   padding-top: 16px;
@@ -131,8 +131,41 @@ body::before {
   text-transform: uppercase;
 }
 
+.rail-heading-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  margin-bottom: 8px;
+}
+
+.rail-heading-row .rail-heading {
+  margin-bottom: 0;
+}
+
+.rail-icon-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  min-width: 28px;
+  height: 28px;
+  padding: 0;
+  border: 1px solid var(--line-strong);
+  border-radius: 8px;
+  background: #fff9e9;
+  color: var(--forest);
+  box-shadow: 0 8px 18px rgba(38, 58, 27, 0.08);
+}
+
+.rail-icon-button svg {
+  width: 15px;
+  height: 15px;
+}
+
 .chat-list,
-.inbox-list {
+.inbox-list,
+.plans-rail-list {
   display: grid;
   gap: 8px;
   max-height: calc(100% - 26px);
@@ -140,7 +173,8 @@ body::before {
 }
 
 .chat-item,
-.inbox-item {
+.inbox-item,
+.plan-rail-item {
   display: grid;
   align-items: center;
   gap: 6px;
@@ -159,13 +193,33 @@ body::before {
   grid-template-columns: minmax(0, 1fr) auto auto;
 }
 
+.plan-rail-item {
+  grid-template-columns: minmax(0, 1fr) auto;
+  width: 100%;
+  min-width: 0;
+  border: 1px solid var(--line);
+  background: rgba(255, 250, 240, 0.78);
+  color: var(--brown);
+  font-family: Inter, "Segoe UI", Arial, sans-serif;
+  text-align: left;
+  box-shadow: none;
+  cursor: pointer;
+}
+
+.plan-rail-item:hover {
+  background: #edf3df;
+  color: var(--brown);
+  box-shadow: none;
+}
+
 .chat-item.active {
   border-color: rgba(52, 83, 38, 0.42);
   background: #edf3df;
 }
 
 .chat-title,
-.inbox-title {
+.inbox-title,
+.plan-rail-title {
   min-width: 0;
   overflow: hidden;
   color: var(--brown);
@@ -198,7 +252,25 @@ body::before {
   -webkit-box-orient: vertical;
 }
 
+.plan-rail-title {
+  white-space: nowrap;
+}
+
+.plan-rail-status {
+  min-width: 0;
+  padding: 3px 6px;
+  border: 1px solid rgba(52, 83, 38, 0.2);
+  border-radius: 999px;
+  background: #edf3df;
+  color: var(--forest);
+  font-size: 10px;
+  font-weight: 800;
+  text-transform: uppercase;
+}
+
 .actions {
+  display: flex;
+  flex-direction: column;
   padding: 28px;
   overflow: auto;
   min-height: 0;
@@ -230,6 +302,10 @@ body::before {
   min-width: 0;
 }
 
+.brand-short {
+  display: none;
+}
+
 .logo-wrap {
   position: relative;
   display: grid;
@@ -481,6 +557,38 @@ h2 {
   background: rgba(255, 250, 240, 0.96);
 }
 
+.message-images {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(132px, 1fr));
+  gap: 10px;
+  margin-bottom: 12px;
+}
+
+.message-image {
+  overflow: hidden;
+  border: 1px solid rgba(88, 66, 47, 0.18);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.78);
+}
+
+.message-image img {
+  display: block;
+  width: 100%;
+  aspect-ratio: 1 / 1;
+  object-fit: cover;
+}
+
+.message-image-label {
+  display: block;
+  padding: 8px 10px;
+  color: #6d5b4e;
+  font-size: 12px;
+  font-weight: 700;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
 .message.warning-message {
   border-color: rgba(212, 175, 55, 0.6);
   background: #f5eac4;
@@ -646,6 +754,60 @@ h2 {
   padding: 20px;
 }
 
+.composer-main {
+  display: grid;
+  gap: 12px;
+}
+
+.composer-images {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+  gap: 10px;
+}
+
+.composer-image {
+  position: relative;
+  overflow: hidden;
+  border: 1px solid rgba(88, 66, 47, 0.16);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.88);
+  box-shadow: 0 12px 26px rgba(38, 58, 27, 0.08);
+}
+
+.composer-image img {
+  display: block;
+  width: 100%;
+  aspect-ratio: 1 / 1;
+  object-fit: cover;
+}
+
+.composer-image-name {
+  display: block;
+  padding: 8px 10px 10px;
+  color: #6d5b4e;
+  font-size: 12px;
+  font-weight: 700;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.composer-image-remove {
+  position: absolute;
+  top: 8px;
+  right: 8px;
+  width: 28px;
+  height: 28px;
+  min-height: 28px;
+  padding: 0;
+  border-radius: 999px;
+  border: 1px solid rgba(88, 66, 47, 0.18);
+  background: rgba(255, 250, 240, 0.92);
+  color: var(--brown);
+  font-size: 16px;
+  line-height: 1;
+}
+
 textarea {
   width: 100%;
   min-height: 58px;
@@ -678,7 +840,8 @@ textarea:disabled {
 
 input[type="text"],
 input[type="password"],
-input[type="number"] {
+input[type="number"],
+select {
   width: 100%;
   min-height: 38px;
   padding: 9px 11px;
@@ -694,7 +857,8 @@ input[type="number"] {
 
 input[type="text"]:focus,
 input[type="password"]:focus,
-input[type="number"]:focus {
+input[type="number"]:focus,
+select:focus {
   border-color: var(--gold);
   box-shadow: 0 0 0 3px rgba(212, 175, 55, 0.18);
 }
@@ -867,6 +1031,26 @@ button {
   line-height: 1.45;
 }
 
+.floating-panel-actions {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.plans-floating-panel {
+  grid-template-rows: auto minmax(0, 1fr);
+  width: min(980px, calc(100vw - 28px));
+}
+
+.plans-panel-body {
+  display: grid;
+  grid-template-columns: minmax(280px, 340px) minmax(0, 1fr);
+  gap: 20px;
+  min-height: 0;
+  padding: 20px;
+  overflow: auto;
+}
+
 button:hover {
   background: linear-gradient(180deg, #3d612c, #263e1b);
   box-shadow: 0 18px 34px rgba(31, 52, 22, 0.28), inset 0 1px 0 rgba(255, 255, 255, 0.16);
@@ -909,7 +1093,7 @@ button.secondary {
 }
 
 .side-section {
-  margin-bottom: 28px;
+  margin-bottom: 0;
 }
 
 .side-section + .side-section {
@@ -918,43 +1102,98 @@ button.secondary {
 }
 
 .sidebar-tools {
-  display: grid;
+  display: flex;
+  flex-direction: column;
   gap: 14px;
+  margin-top: auto;
+  padding-top: 24px;
+  background: transparent;
 }
 
 .sidebar-tool-buttons {
-  display: grid;
+  display: flex;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
+  flex-wrap: nowrap;
-  gap: 10px;
+  justify-content: flex-end;
+  width: 100%;
+  min-width: 0;
+  gap: 8px;
+  position: sticky;
+  bottom: 0;
+  z-index: 2;
+  padding-top: 14px;
+  padding-bottom: 2px;
+  background: linear-gradient(180deg, var(--ivory) 0%, var(--cream) 100%);
 }
 
 .sidebar-tool-button {
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  gap: 8px;
+  flex: 0 1 42px;
-  min-width: 0;
+  gap: 0;
-  min-height: 46px;
+  width: 42px;
-  padding: 10px 12px;
+  min-width: 36px;
+  min-height: 42px;
+  padding: 9px;
+  overflow: hidden;
   border: 1px solid var(--line-strong);
-  border-radius: 14px;
+  border-radius: 12px;
   background: #fff9e9;
   color: var(--forest);
   font-family: Inter, "Segoe UI", Arial, sans-serif;
-  font-size: 13px;
+  font-size: 12px;
   font-weight: 800;
+  white-space: nowrap;
   box-shadow: 0 10px 22px rgba(38, 58, 27, 0.08);
+  transition:
+    flex-basis 180ms ease,
+    width 180ms ease,
+    gap 180ms ease,
+    padding 180ms ease,
+    border-color 180ms ease,
+    background 180ms ease,
+    color 180ms ease,
+    box-shadow 180ms ease,
+    transform 180ms ease;
+}
+
+.sidebar-tool-button:hover,
+.sidebar-tool-button:focus-visible {
+  flex-basis: 108px;
+  width: 108px;
+  gap: 7px;
+  padding-inline: 12px;
+  border-color: rgba(212, 175, 55, 0.72);
+  background: linear-gradient(180deg, #3d612c, #263e1b);
+  color: var(--ivory);
+}
+
+.sidebar-tool-button span {
+  max-width: 0;
+  overflow: hidden;
+  opacity: 0;
+  transition:
+    max-width 180ms ease,
+    opacity 140ms ease;
+}
+
+.sidebar-tool-button:hover span,
+.sidebar-tool-button:focus-visible span {
+  max-width: 70px;
+  opacity: 1;
 }
 
 .sidebar-tool-button svg {
   width: 18px;
   height: 18px;
+  flex: 0 0 18px;
   stroke-width: 2.3;
 }
 
 .sidebar-tool-image {
   width: 18px;
   height: 18px;
+  flex: 0 0 18px;
   object-fit: contain;
 }
 
@@ -969,8 +1208,13 @@ button.secondary {
 }
 
 .sidebar-panel {
-  padding-top: 12px;
+  padding-bottom: 12px;
-  border-top: 1px solid var(--line);
+  border-bottom: 1px solid var(--line);
+}
+
+.sidebar-panel .section-title-row {
+  position: relative;
+  z-index: 1;
 }
 
 .config-form {
@@ -1013,6 +1257,77 @@ button.secondary {
   font-weight: 800;
 }
 
+.plan-creator-shell,
+.plans-dashboard-shell {
+  min-height: 0;
+}
+
+.plan-creator-card {
+  display: grid;
+  gap: 18px;
+  padding: 20px;
+  border: 1px solid rgba(212, 175, 55, 0.28);
+  border-radius: 22px;
+  background:
+    radial-gradient(circle at top right, rgba(240, 214, 129, 0.18), transparent 34%),
+    linear-gradient(180deg, rgba(255, 253, 247, 0.98), rgba(247, 241, 220, 0.94));
+  box-shadow: 0 20px 40px rgba(38, 58, 27, 0.08);
+}
+
+.plan-creator-copy {
+  display: grid;
+  gap: 8px;
+}
+
+.plan-creator-copy h3 {
+  margin: 0;
+  color: var(--forest);
+  font-family: "Playfair Display", Georgia, serif;
+  font-size: 28px;
+  line-height: 1.02;
+}
+
+.plan-creator-copy p:last-child {
+  margin: 0;
+  color: var(--muted);
+  font-size: 13px;
+  line-height: 1.55;
+}
+
+.plan-form-grid {
+  gap: 12px;
+}
+
+.plan-form-grid textarea {
+  min-height: 96px;
+}
+
+.plan-form-split {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.plan-form-hint {
+  display: grid;
+  align-content: start;
+  gap: 4px;
+  padding: 12px 13px;
+  border: 1px dashed rgba(52, 83, 38, 0.24);
+  border-radius: 14px;
+  background: rgba(237, 243, 223, 0.68);
+  color: var(--muted);
+  font-size: 12px;
+  line-height: 1.45;
+}
+
+.plan-form-hint strong {
+  color: var(--forest);
+  font-size: 11px;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
 .ollama-status {
   display: grid;
   gap: 8px;
@@ -1245,6 +1560,300 @@ pre {
   padding: 11px;
 }
 
+.plans-dashboard {
+  display: grid;
+  gap: 14px;
+  min-height: 0;
+}
+
+.plans-overview {
+  display: flex;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 18px;
+  padding: 6px 2px 10px;
+}
+
+.plans-overview h3 {
+  margin: 4px 0 0;
+  color: var(--forest);
+  font-family: "Playfair Display", Georgia, serif;
+  font-size: 31px;
+  line-height: 1.04;
+}
+
+.plan-overview-copy {
+  max-width: 48ch;
+  margin: 8px 0 0;
+  color: var(--muted);
+  font-size: 13px;
+  line-height: 1.5;
+}
+
+.plan-overview-stats {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+}
+
+.plan-overview-stat {
+  display: grid;
+  gap: 2px;
+  min-width: 110px;
+  padding: 12px 14px;
+  border: 1px solid rgba(212, 175, 55, 0.28);
+  border-radius: 16px;
+  background: rgba(255, 250, 240, 0.78);
+  box-shadow: 0 12px 24px rgba(38, 58, 27, 0.06);
+}
+
+.plan-overview-stat-value {
+  color: var(--forest);
+  font-size: 24px;
+  font-weight: 800;
+  line-height: 1;
+}
+
+.plan-overview-stat-label {
+  color: var(--muted);
+  font-size: 11px;
+  font-weight: 800;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.plan-empty-state {
+  padding: 22px;
+  border: 1px dashed rgba(52, 83, 38, 0.24);
+  border-radius: 22px;
+  background: rgba(255, 253, 247, 0.72);
+}
+
+.plan-empty-state h4 {
+  margin: 0 0 6px;
+  color: var(--forest);
+  font-size: 18px;
+}
+
+.plan-empty-state p {
+  margin: 0;
+  color: var(--muted);
+  font-size: 13px;
+  line-height: 1.5;
+}
+
+.plan-card {
+  display: grid;
+  gap: 12px;
+  padding: 16px;
+  border: 1px solid rgba(221, 206, 176, 0.92);
+  border-radius: 20px;
+  background:
+    linear-gradient(180deg, rgba(255, 252, 246, 0.96), rgba(251, 244, 223, 0.88));
+  box-shadow: 0 16px 30px rgba(38, 58, 27, 0.06);
+}
+
+.plan-card.active {
+  border-color: rgba(52, 83, 38, 0.32);
+  background:
+    radial-gradient(circle at top right, rgba(190, 212, 144, 0.22), transparent 26%),
+    linear-gradient(180deg, rgba(247, 250, 238, 0.98), rgba(237, 243, 223, 0.96));
+}
+
+.plan-card-heading {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.plan-card h3 {
+  margin: 0;
+  color: var(--forest);
+  font-size: 19px;
+  line-height: 1.18;
+}
+
+.plan-status-badge {
+  flex: 0 0 auto;
+  padding: 6px 10px;
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 800;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.plan-status-active {
+  border-color: rgba(52, 83, 38, 0.28);
+  background: rgba(237, 243, 223, 0.9);
+  color: var(--forest);
+}
+
+.plan-status-badge.plan-status-active {
+  border: 1px solid rgba(52, 83, 38, 0.24);
+}
+
+.plan-status-paused {
+  border-color: rgba(196, 170, 115, 0.42);
+  background: rgba(255, 246, 220, 0.86);
+  color: #7a5a18;
+}
+
+.plan-status-badge.plan-status-paused {
+  border: 1px solid rgba(196, 170, 115, 0.34);
+}
+
+.plan-status-needs-input {
+  border-color: rgba(159, 60, 50, 0.24);
+  background: rgba(255, 241, 237, 0.88);
+  color: var(--danger);
+}
+
+.plan-status-badge.plan-status-needs-input {
+  border: 1px solid rgba(159, 60, 50, 0.22);
+}
+
+.plan-status-canceled,
+.plan-status-completed {
+  opacity: 0.84;
+}
+
+.plan-status-badge.plan-status-canceled,
+.plan-status-badge.plan-status-completed {
+  border: 1px solid rgba(111, 91, 80, 0.18);
+  background: rgba(255, 250, 240, 0.82);
+  color: var(--muted);
+}
+
+.plan-meta,
+.plan-line {
+  color: var(--muted);
+  font-size: 13px;
+  line-height: 1.55;
+  overflow-wrap: anywhere;
+}
+
+.plan-pill-row,
+.plan-controls {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.plan-pill {
+  display: inline-flex;
+  align-items: center;
+  min-height: 26px;
+  padding: 4px 10px;
+  border: 1px solid rgba(52, 83, 38, 0.14);
+  border-radius: 999px;
+  background: rgba(255, 250, 240, 0.88);
+  color: var(--forest);
+  font-size: 11px;
+  font-weight: 800;
+  text-transform: uppercase;
+}
+
+.plan-metrics {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.plan-metric {
+  display: grid;
+  gap: 4px;
+  padding: 11px 12px;
+  border: 1px solid rgba(221, 206, 176, 0.78);
+  border-radius: 14px;
+  background: rgba(255, 253, 247, 0.76);
+}
+
+.plan-metric-label {
+  color: var(--muted);
+  font-size: 11px;
+  font-weight: 800;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.plan-metric-value {
+  color: var(--brown);
+  font-size: 13px;
+  font-weight: 700;
+  line-height: 1.35;
+}
+
+.plan-controls button {
+  flex: 1 1 80px;
+  min-width: 0;
+}
+
+.plan-detail {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 12px;
+  padding-top: 10px;
+  border-top: 1px solid rgba(221, 206, 176, 0.92);
+}
+
+.plan-detail-loading {
+  grid-template-columns: 1fr;
+  padding: 16px;
+  border: 1px dashed rgba(52, 83, 38, 0.2);
+  border-radius: 16px;
+  background: rgba(255, 253, 247, 0.72);
+  color: var(--muted);
+  font-size: 13px;
+  text-align: center;
+}
+
+.plan-section {
+  display: grid;
+  gap: 8px;
+}
+
+.plan-detail h4 {
+  margin: 0;
+  color: var(--forest);
+  font-size: 13px;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
+.plan-list {
+  display: grid;
+  gap: 6px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.plan-list li {
+  display: grid;
+  gap: 5px;
+  padding: 10px 11px;
+  border: 1px solid rgba(221, 206, 176, 0.72);
+  border-radius: 12px;
+  background: rgba(255, 253, 247, 0.8);
+  color: var(--brown);
+  font-size: 12px;
+  line-height: 1.4;
+}
+
+.plan-list-title {
+  color: var(--forest);
+  font-size: 12px;
+  font-weight: 800;
+}
+
+.plan-list-body {
+  color: var(--muted);
+  font-size: 12px;
+  line-height: 1.5;
+}
+
 .decline-button {
   border: 1px solid var(--line-strong);
   background: #fff9e9;
@@ -1277,8 +1886,17 @@ pre {
 }
 
 @media (max-width: 620px) {
+  body {
+    background: var(--cream);
+  }
+
+  body::before {
+    display: none;
+  }
+
   .shell {
     gap: 14px;
+    grid-template-rows: minmax(0, 1fr) minmax(220px, 34vh);
     padding: 10px;
   }
 
@@ -1287,40 +1905,104 @@ pre {
     border-radius: 22px;
   }
 
+  .chat-rail {
+    position: fixed;
+    inset: 10px auto auto 10px;
+    z-index: 10;
+    width: min(320px, calc(100vw - 20px));
+    height: calc(100vh - 20px);
+    max-height: calc(100vh - 20px);
+  }
+
+  .chat-rail.collapsed {
+    width: 48px;
+    height: 48px;
+    min-height: 48px;
+    max-height: 48px;
+    padding: 4px;
+    border: 0;
+    background: transparent;
+    box-shadow: none;
+  }
+
+  .chat-rail.collapsed .chat-rail-top {
+    display: block;
+  }
+
+  .chat-rail.collapsed #new-chat {
+    display: none;
+  }
+
   .topbar {
-    align-items: flex-start;
+    display: flex;
-    grid-template-columns: 1fr;
+    align-items: center;
-    padding: 22px;
+    justify-content: center;
+    min-height: 68px;
+    padding: 10px 58px 10px 66px;
+    border-bottom-color: var(--line);
+    background: linear-gradient(180deg, var(--ivory) 0%, var(--cream) 100%);
   }
 
   .brand-block {
-    align-items: flex-start;
+    align-items: center;
+    justify-content: center;
+    gap: 9px;
+    min-width: 0;
   }
 
   .logo-wrap {
-    width: 58px;
+    width: 28px;
-    height: 58px;
+    height: 28px;
-    flex-basis: 58px;
+    flex: 0 0 28px;
-    border-radius: 18px;
+    border: 0;
+    border-radius: 0;
+    background: transparent;
+    box-shadow: none;
+    color: var(--brown);
+  }
+
+  .logo-wrap::before {
+    content: "";
+    display: block;
+    width: 28px;
+    height: 28px;
+    background: currentColor;
+    -webkit-mask: url("/static/art/LBC_Logo.png") center / contain no-repeat;
+    mask: url("/static/art/LBC_Logo.png") center / contain no-repeat;
   }
 
   .logo-wrap img {
-    width: 45px;
+    display: none;
-    height: 45px;
+  }
+
+  .brand-copy {
+    display: contents;
+  }
+
+  .brand-copy p,
+  .status {
+    display: none;
   }
 
   h1 {
-    font-size: 31px;
+    color: var(--brown);
+    font-size: 22px;
+    line-height: 1;
+    text-shadow: none;
   }
 
-  .eyebrow {
+  .brand-short {
-    font-size: 10px;
+    display: inline-flex;
-    letter-spacing: 0.08em;
+    align-items: center;
+    color: var(--brown);
+    font-family: "Playfair Display", Georgia, serif;
+    font-size: 18px;
+    font-weight: 800;
+    line-height: 1;
   }
 
   .messages,
-  .actions,
+  .actions {
-  .chat-rail {
     padding: 22px;
   }
 
@@ -1350,4 +2032,40 @@ pre {
   .message-phase {
     grid-column: 1;
   }
+
+  .plans-overview {
+    flex-direction: column;
+    align-items: flex-start;
+  }
+
+  .plan-detail {
+    grid-template-columns: 1fr;
+  }
+}
+
+@media (max-width: 760px) {
+  .plan-form-split,
+  .plan-metrics {
+    grid-template-columns: 1fr;
+  }
+
+  .plan-card-heading {
+    flex-direction: column;
+  }
+
+  .plan-status-badge {
+    align-self: flex-start;
+  }
+}
+
+@media (max-width: 640px) {
+  .plans-floating-panel {
+    width: min(100vw - 18px, 980px);
+    right: 9px;
+    bottom: 9px;
+  }
+
+  .plans-panel-body {
+    grid-template-columns: 1fr;
+  }
 }