fix: resolve 6 dashboard bugs and rebuild Task Queue + Work Orders (#144) (#144)

Round 2+3 bug fix batch:

1. Ollama timeout: Add request_timeout=300 to prevent socket read errors
   on complex 30-60s prompts (production crash fix)

2. Memory API: Create missing HTMX partial templates (memory_facts.html,
   memory_results.html) so Save/Search buttons work

3. CALM page: Add create_tables() call so SQLAlchemy tables exist on
   first request (was returning HTTP 500)

4. Task Queue: Full SQLite-backed rebuild with CRUD endpoints, HTMX
   partials, and action buttons (approve/veto/pause/cancel/retry)

5. Work Orders: Full SQLite-backed rebuild with submit/approve/reject/
   execute pipeline and HTMX polling partials

6. Memory READ tool: Add memory_read function so Timmy stops calling
   read_file when trying to recall stored facts

Also: Close GitHub issues #115, #114, #112, #110 as won't-fix.
Comment on #107 confirming prune_memories() already wired to startup.

Tests: 33 new tests across 4 test files, all passing.
Full suite: 1155 passed, 2 pre-existing failures (hands_shell).

Co-authored-by: Trip T <trip@local>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

tests/conftest.py

@@ -61,6 +61,8 @@ def clean_database(tmp_path):
     tmp_swarm_db = tmp_path / "swarm.db"
     tmp_spark_db = tmp_path / "spark.db"
     tmp_self_coding_db = tmp_path / "self_coding.db"
+    tmp_tasks_db = tmp_path / "tasks.db"
+    tmp_work_orders_db = tmp_path / "work_orders.db"
 
     _swarm_db_modules = [
         "timmy.memory.vector_store",
@@ -98,6 +100,18 @@ def clean_database(tmp_path):
         except Exception:
             pass
 
+    # Redirect task queue and work orders DBs to temp dir
+    for mod_name, tmp_db in [
+        ("dashboard.routes.tasks", tmp_tasks_db),
+        ("dashboard.routes.work_orders", tmp_work_orders_db),
+    ]:
+        try:
+            mod = __import__(mod_name, fromlist=["DB_PATH"])
+            originals[(mod_name, "DB_PATH")] = getattr(mod, "DB_PATH")
+            setattr(mod, "DB_PATH", tmp_db)
+        except Exception:
+            pass
+
     yield
 
     for (mod_name, attr), original in originals.items():

tests/dashboard/test_memory_api.py

@@ -0,0 +1,69 @@
+"""Tests for the Memory API endpoints.
+
+Verifies that facts can be created, searched, edited, and deleted
+through the dashboard memory routes.
+"""
+
+
+def test_memory_page_returns_200(client):
+    response = client.get("/memory")
+    assert response.status_code == 200
+    assert "Memory Browser" in response.text
+
+
+def test_add_fact_returns_html(client):
+    """POST /memory/fact should return HTML partial with the new fact."""
+    response = client.post("/memory/fact", data={"fact": "Alexander is the operator"})
+    assert response.status_code == 200
+    assert "Alexander is the operator" in response.text
+
+
+def test_add_fact_persists(client):
+    """After adding a fact, it should appear on the main memory page."""
+    client.post("/memory/fact", data={"fact": "Timmy runs on Qwen"})
+    response = client.get("/memory")
+    assert response.status_code == 200
+    assert "Timmy runs on Qwen" in response.text
+
+
+def test_memory_search_returns_html(client):
+    """POST /memory/search should return HTML partial."""
+    response = client.post("/memory/search", data={"query": "test query"})
+    assert response.status_code == 200
+
+
+def test_edit_fact(client):
+    """PUT /memory/fact/{id} should update the fact content."""
+    # First create a fact
+    client.post("/memory/fact", data={"fact": "Original fact"})
+
+    # Get the fact ID from the memory page
+    page = client.get("/memory")
+    assert "Original fact" in page.text
+
+    # Extract a fact ID from the page (look for fact- pattern)
+    import re
+    match = re.search(r'id="fact-([^"]+)"', page.text)
+    if match:
+        fact_id = match.group(1)
+        response = client.put(
+            f"/memory/fact/{fact_id}",
+            json={"content": "Updated fact"},
+        )
+        assert response.status_code == 200
+        assert response.json()["success"] is True
+
+
+def test_delete_fact(client):
+    """DELETE /memory/fact/{id} should remove the fact."""
+    # Create a fact
+    client.post("/memory/fact", data={"fact": "Fact to delete"})
+
+    page = client.get("/memory")
+    import re
+    match = re.search(r'id="fact-([^"]+)"', page.text)
+    if match:
+        fact_id = match.group(1)
+        response = client.delete(f"/memory/fact/{fact_id}")
+        assert response.status_code == 200
+        assert response.json()["success"] is True

tests/dashboard/test_tasks_api.py

@@ -0,0 +1,91 @@
+"""Tests for the Task Queue API endpoints.
+
+Verifies task CRUD operations and the dashboard page rendering.
+"""
+
+
+def test_tasks_page_returns_200(client):
+    response = client.get("/tasks")
+    assert response.status_code == 200
+    assert "TASK QUEUE" in response.text
+
+
+def test_create_task(client):
+    """POST /api/tasks returns 201 with task JSON."""
+    response = client.post("/api/tasks", json={
+        "title": "Fix the memory bug",
+        "priority": "high",
+    })
+    assert response.status_code == 201
+    data = response.json()
+    assert data["title"] == "Fix the memory bug"
+    assert data["priority"] == "high"
+    assert data["status"] == "pending_approval"
+    assert "id" in data
+
+
+def test_list_tasks(client):
+    """GET /api/tasks returns JSON array."""
+    response = client.get("/api/tasks")
+    assert response.status_code == 200
+    assert isinstance(response.json(), list)
+
+
+def test_create_and_list_roundtrip(client):
+    """Creating a task makes it appear in the list."""
+    client.post("/api/tasks", json={"title": "Roundtrip test"})
+    response = client.get("/api/tasks")
+    tasks = response.json()
+    assert any(t["title"] == "Roundtrip test" for t in tasks)
+
+
+def test_update_task_status(client):
+    """PATCH /api/tasks/{id}/status updates the task."""
+    create = client.post("/api/tasks", json={"title": "To approve"})
+    task_id = create.json()["id"]
+
+    response = client.patch(
+        f"/api/tasks/{task_id}/status",
+        json={"status": "approved"},
+    )
+    assert response.status_code == 200
+    assert response.json()["status"] == "approved"
+
+
+def test_delete_task(client):
+    """DELETE /api/tasks/{id} removes the task."""
+    create = client.post("/api/tasks", json={"title": "To delete"})
+    task_id = create.json()["id"]
+
+    response = client.delete(f"/api/tasks/{task_id}")
+    assert response.status_code == 200
+
+    # Verify it's gone
+    tasks = client.get("/api/tasks").json()
+    assert not any(t["id"] == task_id for t in tasks)
+
+
+def test_create_task_missing_title_422(client):
+    """POST /api/tasks without title returns 422."""
+    response = client.post("/api/tasks", json={"priority": "high"})
+    assert response.status_code == 422
+
+
+def test_create_task_via_form(client):
+    """POST /tasks/create via form creates and returns task card HTML."""
+    response = client.post("/tasks/create", data={
+        "title": "Form task",
+        "description": "Created via form",
+        "priority": "normal",
+        "assigned_to": "",
+    })
+    assert response.status_code == 200
+    assert "Form task" in response.text
+
+
+def test_pending_partial(client):
+    """GET /tasks/pending returns HTML partial."""
+    client.post("/api/tasks", json={"title": "Pending task"})
+    response = client.get("/tasks/pending")
+    assert response.status_code == 200
+    assert "Pending task" in response.text

tests/dashboard/test_work_orders_api.py

@@ -0,0 +1,64 @@
+"""Tests for the Work Orders API endpoints."""
+
+
+def test_work_orders_page_returns_200(client):
+    response = client.get("/work-orders/queue")
+    assert response.status_code == 200
+    assert "WORK ORDERS" in response.text
+
+
+def test_submit_work_order(client):
+    """POST /work-orders/submit creates a work order."""
+    response = client.post("/work-orders/submit", data={
+        "title": "Fix the dashboard",
+        "description": "Details here",
+        "priority": "high",
+        "category": "bug",
+        "submitter": "dashboard",
+        "related_files": "src/app.py",
+    })
+    assert response.status_code == 200
+
+
+def test_pending_partial_returns_200(client):
+    """GET /work-orders/queue/pending returns HTML."""
+    response = client.get("/work-orders/queue/pending")
+    assert response.status_code == 200
+
+
+def test_active_partial_returns_200(client):
+    """GET /work-orders/queue/active returns HTML."""
+    response = client.get("/work-orders/queue/active")
+    assert response.status_code == 200
+
+
+def test_submit_and_list_roundtrip(client):
+    """Submitting a work order makes it appear in the pending section."""
+    client.post("/work-orders/submit", data={
+        "title": "Roundtrip WO",
+        "priority": "medium",
+        "category": "suggestion",
+        "submitter": "test",
+    })
+    response = client.get("/work-orders/queue/pending")
+    assert "Roundtrip WO" in response.text
+
+
+def test_approve_work_order(client):
+    """POST /work-orders/{id}/approve changes status."""
+    # Submit one first
+    client.post("/work-orders/submit", data={
+        "title": "To approve",
+        "priority": "medium",
+        "category": "suggestion",
+        "submitter": "test",
+    })
+    # Get ID from pending
+    pending = client.get("/work-orders/queue/pending")
+    import re
+    match = re.search(r'id="wo-([^"]+)"', pending.text)
+    if match:
+        wo_id = match.group(1)
+        response = client.post(f"/work-orders/{wo_id}/approve")
+        assert response.status_code == 200
+        assert "APPROVED" in response.text.upper() or "EXECUTE" in response.text.upper()

tests/timmy/test_ollama_timeout.py

@@ -0,0 +1,60 @@
+"""Test that Ollama model is created with a generous request timeout.
+
+The default httpx timeout is too short for complex prompts (30-60s generation).
+This caused socket read errors in production.
+"""
+
+from unittest.mock import patch, MagicMock
+
+
+def test_base_agent_sets_request_timeout():
+    """BaseAgent creates Ollama with request_timeout=300."""
+    with patch("timmy.agents.base.Ollama") as mock_ollama, \
+         patch("timmy.agents.base.Agent"):
+        mock_ollama.return_value = MagicMock()
+
+        # Import after patching to get the patched version
+        from timmy.agents.base import BaseAgent
+
+        class ConcreteAgent(BaseAgent):
+            async def handle_message(self, message: str) -> str:
+                return ""
+
+        # Trigger Ollama construction
+        try:
+            ConcreteAgent(
+                agent_id="test",
+                name="Test",
+                role="tester",
+                system_prompt="You are a test agent.",
+                tools=[],
+            )
+        except Exception:
+            pass  # MCP registry may not be available
+
+        # Verify Ollama was called with request_timeout
+        if mock_ollama.called:
+            _, kwargs = mock_ollama.call_args
+            assert kwargs.get("request_timeout") == 300, (
+                f"Expected request_timeout=300, got {kwargs.get('request_timeout')}"
+            )
+
+
+def test_main_agent_sets_request_timeout():
+    """create_timmy() creates Ollama with request_timeout=300."""
+    with patch("timmy.agent.Ollama") as mock_ollama, \
+         patch("timmy.agent.SqliteDb"), \
+         patch("timmy.agent.Agent"):
+        mock_ollama.return_value = MagicMock()
+
+        from timmy.agent import create_timmy
+        try:
+            create_timmy()
+        except Exception:
+            pass
+
+        if mock_ollama.called:
+            _, kwargs = mock_ollama.call_args
+            assert kwargs.get("request_timeout") == 300, (
+                f"Expected request_timeout=300, got {kwargs.get('request_timeout')}"
+            )

tests/timmy/test_semantic_memory.py

@@ -12,6 +12,7 @@ from timmy.semantic_memory import (
     MemorySearcher,
     MemoryChunk,
     memory_search,
+    memory_read,
     _get_embedding_model,
 )
 
@@ -232,6 +233,22 @@ class TestMemorySearch:
         assert isinstance(result, str)
 
 
+class TestMemoryRead:
+    """Test module-level memory_read function."""
+
+    def test_memory_read_returns_string(self):
+        result = memory_read()
+        assert isinstance(result, str)
+
+    def test_memory_read_with_query(self):
+        result = memory_read("some query")
+        assert isinstance(result, str)
+
+    def test_memory_read_none_top_k(self):
+        result = memory_read("test", top_k=None)
+        assert isinstance(result, str)
+
+
 class TestMemoryChunk:
     """Test MemoryChunk dataclass."""