More fixes

Author: RoyCoding8

backend/app/adapters/llm_client.py

@@ -96,13 +96,6 @@ def generate_json(self, request: LLMGenerateRequest) -> LLMResult:
             }, usage=_zero_usage)
 
         objective = _extract_objective(request.messages)
-        if _stub_should_decompose(objective):
-            children = _stub_split_objective(objective)
-            return LLMResult(data={
-                "decision": "RECURSIVE_CASE",
-                "rationale": "Deterministic stub decomposition (LLM_PROVIDER=stub).",
-                "children": [{"objective": c, "dependencies": [], "needs_qa": False} for c in children],
-            }, usage=_zero_usage)
         return LLMResult(data={
             "decision": "BASE_CASE",
             "rationale": "Deterministic dev/test fallback (LLM_PROVIDER=stub). Use a live provider for production.",
@@ -304,44 +297,19 @@ def _extract_json_from_text(text: str) -> JSONLike | None:
         except json.JSONDecodeError:
             pass
 
-    # Try decoder from each likely JSON start token ({ or [), prefer largest match
+    # Try decoder from each likely JSON start token ({ or [)
     decoder = json.JSONDecoder()
-    best: JSONLike | None = None
-    best_len = 0
     for index, ch in enumerate(text):
         if ch not in "[{":
             continue
         candidate = text[index:].lstrip()
         try:
-            value, end = decoder.raw_decode(candidate)
-            if end > best_len and isinstance(value, (dict, list)):
-                best = value
-                best_len = end
+            value, _ = decoder.raw_decode(candidate)
+            return value
         except json.JSONDecodeError:
             continue
-    return best
-
-
-_DECOMPOSE_MARKERS = (" and ", " then ", " also ", " additionally ", " plus ",
-                      " as well as ", " followed by ", " including ")
-
-
-def _stub_should_decompose(objective: str) -> bool:
-    """Heuristic: does the objective contain multiple distinct tasks?"""
-    lower = objective.lower()
-    return any(m in lower for m in _DECOMPOSE_MARKERS)
-
 
-def _stub_split_objective(objective: str) -> list[str]:
-    """Split objective on conjunction markers into 2-3 child objectives."""
-    import re as _re
-    pattern = "|".join(_re.escape(m.strip()) for m in _DECOMPOSE_MARKERS)
-    parts = [p.strip() for p in _re.split(pattern, objective, flags=_re.IGNORECASE) if p.strip()]
-    if len(parts) < 2:
-        mid = len(objective) // 2
-        space = objective.find(" ", mid)
-        parts = [objective[:space].strip(), objective[space:].strip()] if space > 0 else [objective]
-    return parts[:3]
+    return None
 
 
 def _extract_objective(messages: list[LLMMessage]) -> str:

backend/app/api/runs.py

@@ -4,7 +4,6 @@
 
 import logging
 import os
-import threading
 from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
@@ -51,8 +50,6 @@
 
 _active: dict[str, Any] = {}
 _run_executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix="run-worker")
-_active_runs: set[str] = set()
-_active_runs_lock = threading.Lock()
 
 
 def set_orchestrator_error(exc: Exception | None) -> None:
@@ -248,15 +245,6 @@ def create_run(
     orchestrator: Orchestrator = Depends(get_orchestrator),
 ) -> CreateRunResponse:
     """Create run + root node and launch orchestration asynchronously."""
-    _MAX_OBJECTIVE_LEN = 10000
-    objective = request.objective.strip()
-    if not objective:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="objective must not be empty")
-    if len(objective) > _MAX_OBJECTIVE_LEN:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"objective exceeds maximum length ({len(objective)}/{_MAX_OBJECTIVE_LEN})",
-        )
     if request.base_persona_id:
         registry = _load_persona_registry()
         if not registry.has_profile(request.base_persona_id):
@@ -266,19 +254,11 @@ def create_run(
             )
     try:
         created = orchestrator.create_run(
-            objective=objective,
+            objective=request.objective,
             config=request.config,
             base_persona_id=request.base_persona_id,
         )
 
-        with _active_runs_lock:
-            if created.run_id in _active_runs:
-                raise HTTPException(
-                    status_code=status.HTTP_409_CONFLICT,
-                    detail=f"run {created.run_id} is already executing",
-                )
-            _active_runs.add(created.run_id)
-
         def _run_background() -> None:
             try:
                 orchestrator.run_existing(
@@ -287,25 +267,6 @@ def _run_background() -> None:
                 )
             except Exception:
                 _log.warning("run_existing failed for run=%s", created.run_id, exc_info=True)
-                repo = _active.get("repository")
-                stream = _active.get("event_stream")
-                if repo:
-                    try:
-                        repo.update_run_status(created.run_id, RunStatus.FAILED)
-                    except Exception:
-                        pass
-                if stream:
-                    try:
-                        stream.publish(DomainEvent(
-                            event_id=f"evt_{_default_id_factory()}", run_id=created.run_id,
-                            node_id=created.root_node_id, type=DomainEventType.RUN_FAILED,
-                            payload={"status": RunStatus.FAILED.value, "error": "background_execution_failed"},
-                        ))
-                    except Exception:
-                        pass
-            finally:
-                with _active_runs_lock:
-                    _active_runs.discard(created.run_id)
 
         _run_executor.submit(_run_background)
     except (LLMClientRuntimeError, DividerSchemaError, RuntimeError) as exc:
@@ -546,22 +507,12 @@ def _evt(rtype, payload):
     }))
 
     if target_status == NodeStatus.RUNNING:
-        with _active_runs_lock:
-            if run_id in _active_runs:
-                raise HTTPException(
-                    status_code=status.HTTP_409_CONFLICT,
-                    detail=f"run {run_id} is already executing",
-                )
-            _active_runs.add(run_id)
 
         def _resume_background() -> None:
             try:
                 orchestrator.resume_from_node(run_id=run_id, node_id=node_id)
             except Exception:
                 _log.warning("resume_from_node failed for run=%s node=%s", run_id, node_id, exc_info=True)
-            finally:
-                with _active_runs_lock:
-                    _active_runs.discard(run_id)
 
         _run_executor.submit(_resume_background)
 

backend/app/domain/models.py

@@ -36,8 +36,6 @@ def child(self, objective: str, siblings: list[str] | None = None,
             parent_chain=(*self.parent_chain, objective),
             sibling_objectives=tuple(siblings or ()),
             boundary_constraints=tuple(constraints or ()),
-            checker_feedback=self.checker_feedback,
-            prior_persona_output=self.prior_persona_output,
         )
 
     def with_sibling_output(self, summary: str) -> NodeContext:

backend/app/services/executor.py

@@ -179,10 +179,10 @@ def _check_cancelled(self) -> bool:
         """Return True if cancellation has been requested."""
         return self._cancellation is not None and self._cancellation.is_set()
 
-    def _persist_usage(self, run_id: str, node_id: str) -> bool:
-        """Flush tracked LLM token usage to repository and emit event. Returns True if budget exceeded."""
+    def _persist_usage(self, run_id: str, node_id: str) -> None:
+        """Flush tracked LLM token usage to repository and emit event."""
         if self._usage_tracker is None:
-            return False
+            return
         tokens = self._usage_tracker.total_tokens
         if tokens > 0:
             self._repository.increment_run_tokens(run_id, tokens)
@@ -192,9 +192,6 @@ def _persist_usage(self, run_id: str, node_id: str) -> bool:
             self._usage_tracker.total_tokens = 0
             self._usage_tracker.total_prompt_tokens = 0
             self._usage_tracker.total_completion_tokens = 0
-        run = self._repository.get_run(run_id)
-        budget = run.config.token_budget
-        return budget.on_exhausted == "fail" and run.tokens_used >= budget.max_total_tokens
 
     def execute_node(self, *, run_id: str, node_id: str,
                      node_context: NodeContext | None = None) -> NodeExecutionResult:
@@ -294,12 +291,7 @@ def execute_node(self, *, run_id: str, node_id: str,
                 complexity=complexity,
             )
 
-        budget_exceeded = self._persist_usage(run_id, node_id)
-        if budget_exceeded:
-            self._emit(run_id, node_id, DomainEventType.NODE_STATUS_CHANGED,
-                       {"status": NodeStatus.FAILED_CHECK.value, "reason": "token_budget_exceeded"})
-            return NodeExecutionResult(status=ExecutionTerminal.FAILED, node_id=node_id,
-                                       error="token budget exhausted during execution")
+        self._persist_usage(run_id, node_id)
         return result
 
     def _execute_base_case(
@@ -405,9 +397,6 @@ def _checker_retry_loop(
         consecutive_fails = 0
 
         for _retry in range(max_retries):
-            if node.checker_policy.on_check_fail == "pause":
-                break
-
             fix = checker_result.suggested_fix if checker_result else ""
             violations = list(checker_result.violations) if checker_result else []
             retry_ctx = node_context.with_checker_feedback(fix, violations)

backend/app/services/worker.py

@@ -159,12 +159,8 @@ def _sliding_context(steps: list[str]) -> str:
         return ""
     if len(steps) == 1:
         return steps[0]
-    summary = []
-    for s in steps[:-1]:
-        label, _, output = s.partition(": ")
-        snippet = (output[:120] + "...") if len(output) > 120 else output
-        summary.append(f"{label}: {snippet}" if output else label)
-    return "Previous steps:\n" + "\n".join(summary) + f"\nCurrent step detail:\n{steps[-1]}"
+    summary = [s.split(": ", 1)[0] for s in steps[:-1]]
+    return f"Completed: {'; '.join(summary)}\nLast step detail: {steps[-1]}"
 
 
 def _examples_block(examples: tuple[dict[str, Any], ...]) -> str:

backend/app/state/sqlite_repo.py

@@ -4,7 +4,6 @@
 
 import json
 import sqlite3
-import threading
 from dataclasses import replace
 from datetime import datetime
 from pathlib import Path
@@ -42,8 +41,7 @@ def __init__(
         self._schema_path = (
             Path(schema_path) if schema_path else self._default_schema_path()
         )
-        self._event_lock = threading.Lock()
-        self._conn = sqlite3.connect(self._db_path, check_same_thread=False)
+        self._conn = sqlite3.connect(self._db_path)
         self._conn.row_factory = sqlite3.Row
         self._conn.execute("PRAGMA foreign_keys = ON")
         self._conn.execute("PRAGMA journal_mode = WAL")
@@ -412,41 +410,40 @@ def delete_children_of(self, run_id: str, parent_node_id: str) -> int:
     def append_event(self, event: DomainEvent) -> DomainEvent:
         _ = self.get_run(event.run_id)
         ts = event.ts or utc_now()
-        with self._event_lock:
-            self._conn.execute("BEGIN IMMEDIATE")
-            try:
-                next_seq = self._conn.execute(
-                    "SELECT COALESCE(MAX(seq), 0) + 1 FROM events WHERE run_id = ?",
-                    (event.run_id,),
-                ).fetchone()[0]
-                stored = replace(event, seq=next_seq, ts=ts)
-                self._conn.execute(
-                    """
-                    INSERT INTO events (
-                        event_id,
-                        run_id,
-                        node_id,
-                        seq,
-                        type,
-                        payload_json,
-                        ts
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?)
-                    """,
-                    (
-                        stored.event_id,
-                        stored.run_id,
-                        stored.node_id,
-                        stored.seq,
-                        stored.type.value,
-                        self._to_json(stored.payload),
-                        self._dt(stored.ts),
-                    ),
-                )
-                self._conn.commit()
-                return stored
-            except Exception:
-                self._conn.rollback()
-                raise
+        self._conn.execute("BEGIN IMMEDIATE")
+        try:
+            next_seq = self._conn.execute(
+                "SELECT COALESCE(MAX(seq), 0) + 1 FROM events WHERE run_id = ?",
+                (event.run_id,),
+            ).fetchone()[0]
+            stored = replace(event, seq=next_seq, ts=ts)
+            self._conn.execute(
+                """
+                INSERT INTO events (
+                    event_id,
+                    run_id,
+                    node_id,
+                    seq,
+                    type,
+                    payload_json,
+                    ts
+                ) VALUES (?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    stored.event_id,
+                    stored.run_id,
+                    stored.node_id,
+                    stored.seq,
+                    stored.type.value,
+                    self._to_json(stored.payload),
+                    self._dt(stored.ts),
+                ),
+            )
+            self._conn.commit()
+            return stored
+        except Exception:
+            self._conn.rollback()
+            raise
 
     def list_run_events(self, run_id: str, after_seq: int = 0) -> list[DomainEvent]:
         _ = self.get_run(run_id)

backend/tests/unit/test_core_coverage.py

@@ -13,7 +13,7 @@
     UsageTrackingClient,
 )
 from app.domain.enums import NodeStatus, RunStatus
-from app.domain.models import NodeContext, NodeState
+from app.domain.models import NodeContext, NodeState, RunState
 from app.domain.policies import (
     CheckerFailurePolicy,
     InvalidTransitionError,
@@ -24,6 +24,7 @@
 from app.services.checker import CheckerOutcome, CheckerScope
 from app.services.checker_handler import build_checker_feedback, retry_checker_loop
 
+
 # --- build_checker_feedback ---
 
 class TestBuildCheckerFeedback:
@@ -244,12 +245,12 @@ def test_child_inherits_root(self):
         assert child.checker_feedback is None
         assert child.prior_persona_output is None
 
-    def test_child_inherits_feedback(self):
+    def test_child_does_not_inherit_feedback(self):
         ctx = NodeContext(root_objective="x", checker_feedback="fix it",
                          prior_persona_output="prior")
         child = ctx.child("y")
-        assert child.checker_feedback == "fix it"
-        assert child.prior_persona_output == "prior"
+        assert child.checker_feedback is None
+        assert child.prior_persona_output is None
 
     def test_with_prior_output(self):
         ctx = NodeContext(root_objective="x")
@@ -380,7 +381,7 @@ def test_custom_threshold(self):
 
 class TestNodeStateTiming:
     def test_mark_first_token_computes_ttft(self):
-        from datetime import UTC, datetime, timedelta
+        from datetime import datetime, timedelta, UTC
         start = datetime(2025, 1, 1, 0, 0, 0, tzinfo=UTC)
         token_time = start + timedelta(milliseconds=150)
         node = NodeState(node_id="n1", run_id="r1", objective="test")
@@ -389,7 +390,7 @@ def test_mark_first_token_computes_ttft(self):
         assert node.ttft_ms == 150
 
     def test_mark_first_token_idempotent(self):
-        from datetime import UTC, datetime, timedelta
+        from datetime import datetime, timedelta, UTC
         start = datetime(2025, 1, 1, 0, 0, 0, tzinfo=UTC)
         t1 = start + timedelta(milliseconds=100)
         t2 = start + timedelta(milliseconds=200)
@@ -400,7 +401,7 @@ def test_mark_first_token_idempotent(self):
         assert node.ttft_ms == 100  # first wins
 
     def test_mark_ended_computes_duration(self):
-        from datetime import UTC, datetime, timedelta
+        from datetime import datetime, timedelta, UTC
         start = datetime(2025, 1, 1, 0, 0, 0, tzinfo=UTC)
         end = start + timedelta(seconds=5)
         node = NodeState(node_id="n1", run_id="r1", objective="test")