Reimplement compose and add tiling windows

core/tasks/engine.py

@@ -13,7 +13,6 @@ from core.models import (
     AI,
     Chat,
     ChatTaskSource,
-    CodexRun,
     DerivedTask,
     DerivedTaskEvent,
     ExternalSyncEvent,
@@ -27,8 +26,6 @@ from core.tasks.chat_defaults import (
     ensure_default_source_for_chat,
     resolve_message_scope,
 )
-from core.tasks.codex_approval import queue_codex_event_with_pre_approval
-from core.tasks.codex_support import resolve_external_chat_id
 from core.tasks.providers import get_provider
 
 _TASK_HINT_RE = re.compile(r"\b(todo|task|action|need to|please)\b", re.IGNORECASE)
@@ -506,21 +503,30 @@ async def _derive_title_with_flags(message: Message, flags: dict) -> str:
 async def _emit_sync_event(
     task: DerivedTask, event: DerivedTaskEvent, action: str
 ) -> None:
-    cfg = await sync_to_async(
-        lambda: TaskProviderConfig.objects.filter(user=task.user, enabled=True)
-        .order_by("provider")
-        .first()
-    )()
-    provider_name = str(getattr(cfg, "provider", "mock") or "mock")
-    provider_settings = dict(getattr(cfg, "settings", {}) or {})
+    def _select_provider_config():
+        enabled_cfg = (
+            TaskProviderConfig.objects.filter(user=task.user, enabled=True)
+            .order_by("provider")
+            .first()
+        )
+        if enabled_cfg is not None:
+            return enabled_cfg
+        any_cfg_exists = TaskProviderConfig.objects.filter(user=task.user).exists()
+        if any_cfg_exists:
+            return None
+        return False
+
+    cfg = await sync_to_async(_select_provider_config)()
+    if cfg is None:
+        return
+    if cfg is False:
+        provider_name = "mock"
+        provider_settings = {}
+    else:
+        provider_name = str(getattr(cfg, "provider", "mock") or "mock")
+        provider_settings = dict(getattr(cfg, "settings", {}) or {})
     provider = get_provider(provider_name)
     idempotency_key = f"{provider_name}:{task.id}:{event.id}"
-    external_chat_id = await sync_to_async(resolve_external_chat_id)(
-        user=task.user,
-        provider=provider_name,
-        service=str(task.source_service or ""),
-        channel=str(task.source_channel or ""),
-    )
     cached_project = task._state.fields_cache.get("project")
     cached_epic = task._state.fields_cache.get("epic")
     project_name = str(getattr(cached_project, "name", "") or "")
@@ -545,7 +551,6 @@ async def _emit_sync_event(
         "epic_name": epic_name,
         "source_service": str(task.source_service or ""),
         "source_channel": str(task.source_channel or ""),
-        "external_chat_id": external_chat_id,
         "origin_message_id": str(getattr(task, "origin_message_id", "") or ""),
         "trigger_message_id": str(
             getattr(event, "source_message_id", "")
@@ -556,56 +561,6 @@ async def _emit_sync_event(
         "payload": event.payload,
         "memory_context": memory_context,
     }
-    codex_run = await sync_to_async(CodexRun.objects.create)(
-        user=task.user,
-        task_id=task.id,
-        derived_task_event_id=event.id,
-        source_message_id=(event.source_message_id or task.origin_message_id),
-        project_id=task.project_id,
-        epic_id=task.epic_id,
-        source_service=str(task.source_service or ""),
-        source_channel=str(task.source_channel or ""),
-        external_chat_id=external_chat_id,
-        status="queued",
-        request_payload={
-            "action": action,
-            "provider_payload": dict(request_payload),
-            "idempotency_key": idempotency_key,
-        },
-        result_payload={},
-        error="",
-    )
-    request_payload["codex_run_id"] = str(codex_run.id)
-
-    # Worker-backed providers are queued and executed by `manage.py codex_worker`.
-    if bool(getattr(provider, "run_in_worker", False)):
-        if provider_name == "codex_cli":
-            await sync_to_async(queue_codex_event_with_pre_approval)(
-                user=task.user,
-                run=codex_run,
-                task=task,
-                task_event=event,
-                action=action,
-                provider_payload=dict(request_payload),
-                idempotency_key=idempotency_key,
-            )
-            return
-        await sync_to_async(ExternalSyncEvent.objects.update_or_create)(
-            idempotency_key=idempotency_key,
-            defaults={
-                "user": task.user,
-                "task": task,
-                "task_event": event,
-                "provider": provider_name,
-                "status": "pending",
-                "payload": {
-                    "action": action,
-                    "provider_payload": dict(request_payload),
-                },
-                "error": "",
-            },
-        )
-        return
 
     if action == "create":
         result = provider.create_task(provider_settings, dict(request_payload))
@@ -623,16 +578,14 @@ async def _emit_sync_event(
             "task_event": event,
             "provider": provider_name,
             "status": status,
-            "payload": dict(result.payload or {}),
+            "payload": {
+                "action": action,
+                "provider_payload": dict(request_payload),
+                "result_payload": dict(result.payload or {}),
+            },
             "error": str(result.error or ""),
         },
     )
-    codex_run.status = status
-    codex_run.result_payload = dict(result.payload or {})
-    codex_run.error = str(result.error or "")
-    await sync_to_async(codex_run.save)(
-        update_fields=["status", "result_payload", "error", "updated_at"]
-    )
     if result.ok and result.external_key and not task.external_key:
         task.external_key = str(result.external_key)
         await sync_to_async(task.save)(update_fields=["external_key"])