Merge branch 'main' into ci/claude-review-allowed-bots

Author: frankbria

.gitignore

@@ -98,3 +98,4 @@ tests/e2e/.e2e-state.db*
 test_audit_report.md
 tests/integration/.env.integration
 web-ui/test-results/
+.opencode-tmp/

codeframe/cli/app.py

@@ -4017,14 +4017,19 @@ def batch_status(
 
         if batch_id:
             # Show specific batch
-            # Find by partial ID
-            all_batches = conductor.list_batches(workspace, limit=100)
-            matching = [b for b in all_batches if b.id.startswith(batch_id)]
+            # Find by partial ID (SQL LIKE — no cap, resolves batches beyond 100)
+            matching = conductor.find_batch_by_prefix(workspace, batch_id)
 
             if not matching:
                 console.print(f"[red]Error:[/red] No batch found matching '{batch_id}'")
                 raise typer.Exit(1)
 
+            if len(matching) > 1:
+                console.print(f"[red]Error:[/red] Multiple batches match '{batch_id}':")
+                for b in matching[:5]:
+                    console.print(f"  {b.id[:8]} ({b.status.value})")
+                raise typer.Exit(1)
+
             batch = matching[0]
 
             # Status color
@@ -4162,14 +4167,19 @@ def batch_stop(
     try:
         workspace = get_workspace(path)
 
-        # Find by partial ID
-        all_batches = conductor.list_batches(workspace, limit=100)
-        matching = [b for b in all_batches if b.id.startswith(batch_id)]
+        # Find by partial ID (SQL LIKE — no cap, resolves batches beyond 100)
+        matching = conductor.find_batch_by_prefix(workspace, batch_id)
 
         if not matching:
             console.print(f"[red]Error:[/red] No batch found matching '{batch_id}'")
             raise typer.Exit(1)
 
+        if len(matching) > 1:
+            console.print(f"[red]Error:[/red] Multiple batches match '{batch_id}':")
+            for b in matching[:5]:
+                console.print(f"  {b.id[:8]} ({b.status.value})")
+            raise typer.Exit(1)
+
         batch = matching[0]
 
         if batch.status.value not in ("PENDING", "RUNNING"):
@@ -4231,19 +4241,18 @@ def batch_resume(
     try:
         workspace = get_workspace(path)
 
-        # Find by partial ID
-        all_batches = conductor.list_batches(workspace, limit=100)
-        matching = [b for b in all_batches if b.id.startswith(batch_id)]
+        # Find by partial ID (SQL LIKE — no cap, resolves batches beyond 100)
+        matching = conductor.find_batch_by_prefix(workspace, batch_id)
 
         if not matching:
             console.print(f"[red]Error:[/red] No batch found matching '{batch_id}'")
             raise typer.Exit(1)
 
         if len(matching) > 1:
-            console.print(f"[yellow]Warning:[/yellow] Multiple batches match '{batch_id}':")
+            console.print(f"[red]Error:[/red] Multiple batches match '{batch_id}':")
             for b in matching[:5]:
-                console.print(f"  - {b.id[:8]} ({b.status.value})")
-            console.print("Using the most recent match.")
+                console.print(f"  {b.id[:8]} ({b.status.value})")
+            raise typer.Exit(1)
 
         batch = matching[0]
 
@@ -4430,14 +4439,19 @@ def _update_progress(progress: BatchProgress, event: events.Event) -> None:
     try:
         workspace = get_workspace(path)
 
-        # Find batch by partial ID
-        all_batches = conductor.list_batches(workspace, limit=100)
-        matching = [b for b in all_batches if b.id.startswith(batch_id)]
+        # Find batch by partial ID (SQL LIKE — no cap, resolves batches beyond 100)
+        matching = conductor.find_batch_by_prefix(workspace, batch_id)
 
         if not matching:
             console.print(f"[red]Error:[/red] No batch found matching '{batch_id}'")
             raise typer.Exit(1)
 
+        if len(matching) > 1:
+            console.print(f"[red]Error:[/red] Multiple batches match '{batch_id}':")
+            for b in matching[:5]:
+                console.print(f"  {b.id[:8]} ({b.status.value})")
+            raise typer.Exit(1)
+
         batch = matching[0]
         batch_id_short = batch.id[:8]
 

codeframe/core/adapters/streaming_chat.py

@@ -169,24 +169,40 @@ def __init__(
             db_repo: ``InteractiveSessionRepository`` instance.
             workspace_path: Absolute path used to scope file-system tool calls.
             model: Model identifier passed to the provider's ``async_stream()``.
-            api_key: API key used when constructing the default
-                ``AnthropicProvider`` (when ``provider`` is ``None``).
-            provider: LLM provider to use for streaming.  When ``None``,
-                an ``AnthropicProvider`` is constructed automatically using
-                ``api_key`` or the ``ANTHROPIC_API_KEY`` environment variable.
+                Also threaded into ``resolve_llm_settings`` as ``model_flag``
+                when the provider must be resolved (#861).
+            api_key: Legacy construct — when set AND ``provider`` is ``None``,
+                an ``AnthropicProvider`` is constructed with this key
+                (matches the pre-#861 contract). Ignored if ``provider`` is
+                given. Prefer passing ``provider`` directly.
+            provider: LLM provider to use for streaming.  When ``None`` and
+                ``api_key`` is also ``None``, the provider is resolved via the
+                shared ``llm_resolution`` chain (#861):
+                ``CODEFRAME_LLM_PROVIDER`` → ``.codeframe/config.yaml`` →
+                anthropic.
 
         Raises:
-            ValueError: If no provider is given and no Anthropic API key is
-                available.
+            ValueError: If no provider is given, no ``api_key`` is given, and
+                the chain resolves to a provider whose required API key is
+                missing from the environment.
         """
         if provider is None:
-            # Backward-compatibility fallback: callers that haven't been
-            # updated to pass an explicit provider (e.g. tests using the old
-            # api_key= constructor argument) still get an AnthropicProvider.
-            # New callers should construct the provider themselves and pass it
-            # in — see session_chat_ws.py for the recommended pattern.
-            from codeframe.adapters.llm.anthropic import AnthropicProvider
-            provider = AnthropicProvider(api_key=api_key)
+            if api_key is not None:
+                # Legacy path: explicit api_key always means Anthropic.
+                # Preserves the pre-#861 contract (mirrors PrdDiscoverySession).
+                from codeframe.adapters.llm.anthropic import AnthropicProvider
+
+                provider = AnthropicProvider(api_key=api_key)
+            else:
+                # New: resolve via the shared chain
+                # (CODEFRAME_LLM_PROVIDER → .codeframe/config.yaml → anthropic,
+                # per #861). New callers should construct the provider
+                # themselves and pass it in — see session_chat_ws.py for the
+                # recommended pattern.
+                from codeframe.core.llm_resolution import create_provider, resolve_llm_settings
+
+                settings = resolve_llm_settings(workspace_path, model_flag=model)
+                provider = create_provider(settings)
 
         self._session_id = session_id
         self._db_repo = db_repo

codeframe/core/conductor.py

@@ -119,10 +119,15 @@ def __init__(self, workspace: Workspace):
 
     @property
     def llm(self):
-        """Lazy-load LLM provider."""
+        """Lazy-load LLM provider.
+
+        Resolves via the shared ``llm_resolution`` chain (#861):
+        ``CODEFRAME_LLM_PROVIDER`` → ``.codeframe/config.yaml`` → anthropic.
+        """
         if self._llm is None:
-            from codeframe.adapters.llm import get_provider
-            self._llm = get_provider()
+            from codeframe.core.llm_resolution import create_provider, resolve_llm_settings
+
+            self._llm = create_provider(resolve_llm_settings(self.workspace.repo_path))
         return self._llm
 
     def try_resolve_blocked_task(self, task_id: str) -> bool:
@@ -827,6 +832,48 @@ def list_batches(
     return [_row_to_batch(row) for row in rows]
 
 
+def find_batch_by_prefix(workspace: Workspace, prefix: str) -> list[BatchRun]:
+    """Resolve batches whose id starts with ``prefix`` (SQL ``LIKE``, no cap).
+
+    The CLI accepts partial batch ids. Doing that in Python over
+    ``list_batches(limit=100)`` meant any batch beyond the cap was unreachable
+    (#825). This resolves at the SQL layer with no ``LIMIT`` so every matching
+    batch is addressable regardless of how many batches exist.
+
+    Returns all matches (possibly >1) so callers can report ambiguity.
+
+    Args:
+        workspace: Workspace to query
+        prefix: Batch id prefix (user-typed; may be partial)
+
+    Returns:
+        List of matching BatchRuns, newest first.
+    """
+    # Batch IDs are UUIDs (no _/%), but the prefix is user-typed — escape LIKE
+    # metachars so a stray wildcard can't over-match the wrong batch.
+    escaped = prefix.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+    conn = get_db_connection(workspace)
+    try:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT id, workspace_id, task_ids, status, strategy, max_parallel,
+                   on_failure, started_at, completed_at, results, engine,
+                   isolation, stall_timeout_s, stall_action, concurrency_by_status,
+                   llm_provider, llm_model
+            FROM batch_runs
+            WHERE workspace_id = ? AND id LIKE ? ESCAPE '\\'
+            ORDER BY started_at DESC
+            """,
+            (workspace.id, f"{escaped}%"),
+        )
+        rows = cursor.fetchall()
+    finally:
+        conn.close()
+
+    return [_row_to_batch(row) for row in rows]
+
+
 def cancel_batch(workspace: Workspace, batch_id: str) -> BatchRun:
     """Cancel a running batch.