devcouncil 0.2.0 → 0.3.0

package/src/devcouncil/cli/commands/run.py

@@ -1,3 +1,4 @@
+import logging
 import typer
 from rich.console import Console
 from pathlib import Path
@@ -23,6 +24,7 @@ from devcouncil.cli.commands.init import initialize_project
 from devcouncil.telemetry.traces import TraceLogger
 
 console = Console()
+logger = logging.getLogger(__name__)
 CODING_EXECUTOR_ALIASES = {name: name for name in BUILTIN_CODING_EXECUTOR_NAMES} | AGENT_ALIASES
 
 CODING_EXECUTORS = set(CODING_EXECUTOR_ALIASES.keys())
@@ -58,8 +60,14 @@ def _verify_after_execution(session, task, reqs, router=None, project_root: Path
     """Run deterministic verification after an automated executor finishes."""
     import asyncio
 
+    logger.info("Verifying task %s (router=%s)", task.id, "yes" if router else "no")
     verifier = Verifier(project_root, router=router)
     gaps, evidence = asyncio.run(verifier.verify_task(task, reqs))
+    blocking = [g for g in gaps if g.blocking]
+    logger.info(
+        "Verification of %s: %d gap(s) (%d blocking), %d evidence item(s)",
+        task.id, len(gaps), len(blocking), len(evidence),
+    )
 
     gap_repo = GapRepository(session)
     evidence_repo = EvidenceRepository(session)
@@ -81,6 +89,89 @@ def _verify_after_execution(session, task, reqs, router=None, project_root: Path
     return task.status == "verified"
 
 
+def _build_verification_router(project_root: Path):
+    """Best-effort ``ModelRouter`` for LLM-backed verification after a coding-agent run.
+
+    Without a router the ``Verifier`` runs deterministic checks only (no
+    ``implementation_reviewer`` review, no acceptance-criterion compilation). The native
+    executor already builds a router to *run* the agent and reuses it for verification;
+    CLI coding agents (claude, codex, …) don't need one to execute, so they previously
+    verified without the LLM review at all. Build one here so the review gate guides and
+    monitors execution for those agents too. Per-role provider config means these review
+    roles can run on a different provider than planning (e.g. local Ollama).
+
+    Returns ``None`` when no provider/API key is configured so verification degrades to
+    deterministic-only instead of erroring — the LLM review is an enhancement, not a
+    hard requirement of running a task.
+    """
+    try:
+        config = load_config(project_root)
+        validate_model_provider(config.models.provider)
+        api_key = get_api_key(config.models.provider, project_root)
+        provider = create_provider(
+            config.models.provider, api_key, project_root=project_root, provider_prefs=config.provider
+        )
+        role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
+        return ModelRouter(provider, role_config, project_root=project_root)
+    except Exception:
+        return None
+
+
+def _run_live_review_after_execution(project_root: Path, client: str, task_id: str | None) -> None:
+    """Critique the coding agent's latest turn with the ``live_reviewer`` role.
+
+    This is what makes live review actually fire during ``dev e2e``/``dev run`` (previously
+    it only ran via ``dev watch``). It produces an advisory critique card — it does NOT
+    gate the task; the deterministic/LLM verifier already does that. The card feeds the
+    final report's live-review summary and is routed by per-role config (e.g. a local
+    Ollama ``live_reviewer`` while planning runs on OpenRouter).
+
+    The transcript is resolved the same way ``dev watch`` does — the client's NATIVE
+    session log (e.g. claude's projects JSONL), discovered for this project root — not the
+    executor's streamed ``transcript.txt`` (which only exists with --stream and isn't the
+    structured turn format ``latest_assistant_turn`` parses).
+
+    Best-effort and opt-outable: skipped when ``integrations.live_review.enabled`` is
+    false, when no transcript is found, or on any error — a live-review hiccup must never
+    fail the run.
+    """
+    import asyncio
+
+    try:
+        if not load_config(project_root).integrations.live_review.enabled:
+            return
+        from devcouncil.cli.commands.watch import (
+            _resolve_transcript,
+            _review_turn,
+            _save_card_once,
+            _log_card_reviewed,
+        )
+        from devcouncil.live.transcripts import latest_assistant_turn
+
+        transcript = _resolve_transcript(project_root, client, latest=True)
+        if transcript is None or not transcript.exists():
+            return
+        turn = latest_assistant_turn(transcript, client=client)
+        if turn is None:
+            return
+        card = asyncio.run(_review_turn(turn, project_root, client, use_llm=True, task_id=task_id))
+        saved_path, duplicate = _save_card_once(project_root, card, persist=True, force=False)
+        if saved_path:
+            _log_card_reviewed(project_root, card, saved_path, duplicate=duplicate, source="e2e")
+            console.print(f"[dim]Live review ({card.verdict}): {saved_path}[/dim]")
+    except Exception as exc:  # noqa: BLE001 - advisory; never fail the run on a review hiccup
+        console.print(f"[yellow]Live review skipped: {exc}[/yellow]")
+
+
+def _log_exec_outcome(executor: str, task_id: str, *, verified: bool) -> None:
+    """Log a non-coding-CLI executor's post-verification outcome (verified vs blocked),
+    so standalone ``dev run`` has the same flow-decision trail as ``dev go``."""
+    if verified:
+        logger.info("%s finished and %s verified", executor, task_id)
+    else:
+        logger.warning("%s finished but %s blocked by verification gaps", executor, task_id)
+
+
 def _record_agent_verification(project_root: Path, task_id: str, executor: str, run_id: str | None, verified: bool) -> None:
     TraceLogger(project_root).log_event(
         "agent_run_verified",
@@ -114,6 +205,9 @@ def run(
     Execute a specific task.
     """
     root = project_root.expanduser().resolve()
+    from devcouncil.telemetry.logging_setup import set_log_dir
+    set_log_dir(root)
+    logger.info("dev run: task=%s executor=%s profile=%s stream=%s", task_id, executor, profile, stream)
     initialize_project(root, quiet=True)
     db = get_db(root)
     if not db:
@@ -131,6 +225,10 @@ def run(
         gate_policy = GatePolicy()
         gate_result = gate_policy.check_task_ready(task, root)
         if not gate_result.passed:
+            logger.warning(
+                "Task %s failed readiness gate: %s",
+                task_id, "; ".join(g.description for g in gate_result.gaps if g.blocking),
+            )
             console.print(f"[red]Task {task_id} is not ready for execution.[/red]")
             for gap in gate_result.gaps:
                 if gap.blocking:
@@ -152,7 +250,8 @@ def run(
             console.print(f"[yellow]Warning: Failed to create git checkpoint: {e}[/yellow]")
 
         executor = executor.strip().lower().replace("_", "-")
-        if executor not in CODING_EXECUTORS and executor not in _custom_cli_agents(root):
+        custom_agents = _custom_cli_agents(root)
+        if executor not in CODING_EXECUTORS and executor not in custom_agents:
             ignored = [flag for flag, value in (("--profile", profile), ("--stream", stream)) if value]
             if ignored:
                 console.print(
@@ -162,10 +261,11 @@ def run(
             _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
             task.status = "running"
             task_repo.save(task)
+            logger.info("%s marked RUNNING for manual sidecar execution", task_id)
             console.print(f"\n[green]Task {task_id} is now marked as RUNNING.[/green]")
             console.print("Use 'dev prompt TASK-ID' to get the prompt for this task.")
             console.print("When finished, use 'dev verify TASK-ID' to check the results.")
-        elif executor in CODING_EXECUTORS or executor in _custom_cli_agents(root):
+        elif executor in CODING_EXECUTORS or executor in custom_agents:
             _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
             req_repo = RequirementRepository(session)
             reqs = req_repo.get_all()
@@ -175,7 +275,9 @@ def run(
             _capture_after_patch(task_id, root)
             if exec_result.success:
                 _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, project_root=root)
+                verified = _verify_after_execution(
+                    session, task, reqs, router=_build_verification_router(root), project_root=root
+                )
                 _record_agent_verification(root, task.id, cli_client, getattr(cli_executor, "last_run_id", None), verified)
                 _record_project_phase(
                     session,
@@ -183,17 +285,24 @@ def run(
                 )
                 task_repo.save(task)
                 run_id = getattr(cli_executor, "last_run_id", None)
+                transcript_path = getattr(cli_executor, "last_transcript_path", None)
                 if run_id:
                     run_dir = root / ".devcouncil" / "runs" / run_id
                     console.print(f"Run artifacts: [dim]{run_dir}[/dim]")
-                    transcript_path = getattr(cli_executor, "last_transcript_path", None)
+                    if (run_dir / "run.log").exists():
+                        console.print(f"Run log: [dim]dev logs tail --run {run_id}[/dim]")
                     if transcript_path:
                         console.print(f"Transcript: [dim]{transcript_path}[/dim]")
+                # Live review (advisory): critique the agent's turn with the live_reviewer
+                # role so monitoring actually happens during execution, not only via watch.
+                _run_live_review_after_execution(root, cli_client, task.id)
+                _log_exec_outcome(executor, task_id, verified=verified)
                 if verified:
                     console.print(f"\n[green]{executor.upper()} finished and task {task_id} verified.[/green]")
                 else:
                     console.print(f"\n[yellow]{executor.upper()} finished, but task {task_id} is blocked by verification gaps.[/yellow]")
             else:
+                logger.error("%s failed to start or execute for %s: %s", executor, task_id, exec_result.message)
                 console.print(f"\n[red]{executor.upper()} failed to start or execute: {exec_result.message}[/red]")
         elif executor == "mini":
             _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
@@ -204,17 +313,21 @@ def run(
             _capture_after_patch(task_id, root)
             if exec_result.success:
                 _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, project_root=root)
+                verified = _verify_after_execution(
+                    session, task, reqs, router=_build_verification_router(root), project_root=root
+                )
                 _record_project_phase(
                     session,
                     ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
                 )
                 task_repo.save(task)
+                _log_exec_outcome("mini-SWE-agent", task_id, verified=verified)
                 if verified:
                     console.print(f"\n[green]mini-SWE-agent finished and task {task_id} verified.[/green]")
                 else:
                     console.print(f"\n[yellow]mini-SWE-agent finished, but task {task_id} is blocked by verification gaps.[/yellow]")
             else:
+                logger.error("mini-SWE-agent failed to start or execute for %s", task_id)
                 console.print("\n[red]mini-SWE-agent failed to start or execute.[/red]")
         elif executor == "openhands":
             _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
@@ -225,17 +338,21 @@ def run(
             _capture_after_patch(task_id, root)
             if exec_result.success:
                 _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, project_root=root)
+                verified = _verify_after_execution(
+                    session, task, reqs, router=_build_verification_router(root), project_root=root
+                )
                 _record_project_phase(
                     session,
                     ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
                 )
                 task_repo.save(task)
+                _log_exec_outcome("OpenHands", task_id, verified=verified)
                 if verified:
                     console.print(f"\n[green]OpenHands finished and task {task_id} verified.[/green]")
                 else:
                     console.print(f"\n[yellow]OpenHands finished, but task {task_id} is blocked by verification gaps.[/yellow]")
             else:
+                logger.error("OpenHands failed to start or execute for %s", task_id)
                 console.print("\n[red]OpenHands failed to start or execute.[/red]")
         elif executor in {"native", "native-preview"}:
             # Load config for model routing and permissions
@@ -244,10 +361,11 @@ def run(
                 validate_model_provider(config.models.provider)
                 api_key = get_api_key(config.models.provider, root)
             except (FileNotFoundError, ValueError) as e:
+                logger.error("Native executor cannot start for %s: %s", task_id, e)
                 console.print(f"[red]{e}[/red]")
                 return
             
-            provider = create_provider(config.models.provider, api_key, project_root=root)
+            provider = create_provider(config.models.provider, api_key, project_root=root, provider_prefs=config.provider)
             role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
             router = ModelRouter(provider, role_config, project_root=root)
             
@@ -279,11 +397,14 @@ def run(
                     ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
                 )
                 task_repo.save(task)
+                _log_exec_outcome("Native agent", task_id, verified=verified)
                 if verified:
                     console.print(f"\n[green]Native agent finished and task {task_id} verified.[/green]")
                 else:
                     console.print(f"\n[yellow]Native agent finished, but task {task_id} is blocked by verification gaps.[/yellow]")
             else:
+                logger.error("Native agent failed during execution for %s", task_id)
                 console.print("\n[red]Native agent failed during execution.[/red]")
         else:
+            logger.error("Executor %r not implemented", executor)
             console.print(f"[red]Executor {executor} not yet implemented.[/red]")

package/src/devcouncil/cli/commands/skills.py

@@ -1,10 +1,12 @@
+import asyncio
 from pathlib import Path
 
 import typer
 from rich.console import Console
 from rich.table import Table
 
-from devcouncil.skills.registry import get_skill, load_skills, scaffold_skills, select_skills
+from devcouncil.knowledge.frontmatter import build_frontmatter_markdown
+from devcouncil.skills.registry import Skill, get_skill, load_skills, scaffold_skills, select_skills
 
 app = typer.Typer(help="Inspect and scaffold DevCouncil engineering skills for coding agents.")
 console = Console()
@@ -86,3 +88,180 @@ def scaffold(
     console.print(f"[green]Wrote {len(written)} skill file(s):[/green]")
     for path in written:
         console.print(f"  {path.relative_to(root).as_posix()}")
+
+
+def _skill_to_markdown(skill: Skill, body: str) -> str:
+    """Render a skill back to markdown, preserving its selection frontmatter."""
+    meta: dict[str, object] = {"name": skill.name}
+    if skill.title:
+        meta["title"] = skill.title
+    if skill.description:
+        meta["description"] = skill.description
+    if skill.always:
+        meta["always"] = True
+    triggers = {
+        k: v
+        for k, v in {"keywords": skill.triggers.keywords, "globs": skill.triggers.globs}.items()
+        if v
+    }
+    if triggers:
+        meta["triggers"] = triggers
+    return build_frontmatter_markdown(meta, body)
+
+
+def _write_skill_body(project_root: Path, skill: Skill, body: str) -> Path:
+    """Persist an optimized skill body, overwriting a repo-local skill in place or
+    materializing a packaged-library skill under ``.devcouncil/skills/<name>.md``."""
+    content = _skill_to_markdown(skill, body)
+    if skill.source_path is not None:
+        try:
+            skill.source_path.resolve().relative_to(project_root.resolve())
+            skill.source_path.write_text(content, encoding="utf-8")
+            return skill.source_path
+        except ValueError:
+            pass
+    target = project_root / ".devcouncil" / "skills" / f"{skill.name}.md"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(content, encoding="utf-8")
+    return target
+
+
+def _build_router(project_root: Path):
+    """Build a ModelRouter from project config, adding SkillOpt roles when absent."""
+    from devcouncil.app.config import get_api_key, load_config
+    from devcouncil.llm.provider import create_provider
+    from devcouncil.llm.router import ModelRouter
+
+    config = load_config(project_root)
+    api_key = get_api_key(config.models.provider, project_root)
+    provider = create_provider(config.models.provider, api_key, project_root=project_root, provider_prefs=config.provider)
+    role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
+    if not role_config:
+        raise RuntimeError(
+            "No model roles configured in .devcouncil/config.yaml. "
+            "Run 'dev init' or add a 'models.roles' entry before optimizing."
+        )
+    # SkillOpt's rollout/optimizer roles fall back to a capable existing role when the
+    # project config doesn't define dedicated ones. Copy the dict so the three roles
+    # don't alias one config object.
+    capable = role_config.get("arbiter") or role_config.get("planner_a") or next(iter(role_config.values()))
+    role_config.setdefault("skill_target", dict(capable))
+    role_config.setdefault("skill_optimizer", dict(capable))
+    return ModelRouter(provider, role_config, project_root=project_root)
+
+
+@app.command("optimize")
+def optimize(
+    name: str = typer.Argument(..., help="Skill name to optimize, e.g. core-engineering."),
+    evals_path: Path = typer.Option(..., "--evals", help="JSON or JSONL dataset of evaluation tasks."),
+    profile_name: str = typer.Option(
+        "default", "--profile", help="Agent profile whose prompt preamble (guidance) is co-optimized."
+    ),
+    epochs: int = typer.Option(5, "--epochs", min=1, help="Optimization epochs."),
+    max_edits: int = typer.Option(3, "--max-edits", min=1, help="Edit budget per epoch (textual learning rate)."),
+    val_fraction: float = typer.Option(0.5, "--val-fraction", min=0.0, max=1.0, help="Held-out validation fraction."),
+    seed: int = typer.Option(0, "--seed", help="Seed for the deterministic train/validation split."),
+    apply: bool = typer.Option(
+        False,
+        "--apply/--dry-run",
+        help="Write the optimized skill body and guidance preamble back to disk. Defaults to dry-run.",
+    ),
+    output_path: Path | None = typer.Option(None, "--output", help="Write the optimization artifact to this path."),
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """Co-optimize a skill document and its agent guidance preamble with the SkillOpt loop.
+
+    Each epoch runs the skill+guidance on training tasks, scores the rollouts, and lets an
+    optimizer model propose bounded edits to **both** documents at once; a candidate is kept
+    only if it strictly improves the held-out validation score.
+    """
+    from devcouncil.executors.agent_registry import load_agent_profiles
+    from devcouncil.optimization.gepa_agent import load_agent_eval_dataset
+    from devcouncil.optimization.skillopt import (
+        GUIDANCE,
+        SKILL,
+        DEFAULT_OBJECTIVE,
+        SkillOptConfig,
+        default_artifact_path,
+        make_llm_optimizer,
+        make_llm_rollout,
+        optimize_skill,
+        write_result_artifact,
+    )
+    from devcouncil.optimization.gepa_agent import _apply_profile_preamble
+
+    root = project_root.expanduser().resolve()
+    skill = get_skill(name, project_root=root)
+    if skill is None:
+        console.print(f"[red]No skill named '{name}'. Run 'dev skills' to list available skills.[/red]")
+        raise typer.Exit(code=1)
+
+    resolved_evals = evals_path.expanduser()
+    if not resolved_evals.is_absolute():
+        resolved_evals = root / resolved_evals
+    try:
+        dataset = load_agent_eval_dataset(resolved_evals)
+    except ValueError as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(code=2) from exc
+
+    profiles = load_agent_profiles(root)
+    profile = profiles.get(profile_name)
+    if profile is None:
+        known = ", ".join(sorted(profiles)) or "(none)"
+        console.print(
+            f"[red]No agent profile named '{profile_name}'. Known profiles: {known}.[/red]"
+        )
+        raise typer.Exit(code=2)
+    guidance = profile.prompt_preamble or ""
+
+    try:
+        router = _build_router(root)
+    except (RuntimeError, ValueError, FileNotFoundError) as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(code=1) from exc
+
+    rollout = make_llm_rollout(router)
+    optimizer = make_llm_optimizer(router)
+    result = asyncio.run(
+        optimize_skill(
+            skill_name=skill.name,
+            docs={GUIDANCE: guidance, SKILL: skill.body},
+            dataset=dataset,
+            rollout=rollout,
+            optimizer=optimizer,
+            config=SkillOptConfig(
+                epochs=epochs, max_edits_per_epoch=max_edits, val_fraction=val_fraction, seed=seed
+            ),
+        )
+    )
+
+    artifact_path = (output_path or default_artifact_path(root, skill.name)).expanduser()
+    if not artifact_path.is_absolute():
+        artifact_path = root / artifact_path
+    result.artifact_path = artifact_path
+    result.applied = apply
+    write_result_artifact(
+        artifact_path, result, objective=DEFAULT_OBJECTIVE, dataset_path=str(resolved_evals)
+    )
+
+    if apply and result.improved:
+        # Only write a document that actually changed, so a guidance-only improvement
+        # doesn't churn the skill file (and vice versa).
+        if result.best_skill_body != skill.body:
+            skill_path = _write_skill_body(root, skill, result.best_skill_body)
+            console.print(f"[green]Updated skill body:[/green] {skill_path.relative_to(root).as_posix()}")
+        if result.best_guidance_body != guidance:
+            _apply_profile_preamble(root, profile_name, result.best_guidance_body)
+            console.print(f"[green]Updated guidance preamble for profile '{profile_name}'.[/green]")
+
+    mode = "applied" if (apply and result.improved) else "dry-run"
+    console.print(
+        f"[green]SkillOpt complete ({mode}) for '{skill.name}'.[/green] "
+        f"validation {result.seed_val_score:.3f} -> {result.best_val_score:.3f} "
+        f"over {len(result.epochs)} epoch(s), "
+        f"{result.accepted_edit_count} edit(s) accepted, {result.rejected_edit_count} rejected."
+    )
+    console.print(f"Artifact: [dim]{artifact_path}[/dim]")
+    if apply and not result.improved:
+        console.print("[yellow]No validated improvement — nothing written. Re-run with more epochs or data.[/yellow]")

package/src/devcouncil/cli/commands/status.py

@@ -8,7 +8,7 @@ from devcouncil.cli.commands.init import initialize_project
 from devcouncil.app.project_status import compute_phase
 from devcouncil.storage.db import get_db
 from devcouncil.storage.repositories import ArtifactGraphRepository, StateRepository
-from devcouncil.telemetry.cost import CostEstimator, cost_by_task
+from devcouncil.telemetry.cost import group_cost
 from devcouncil.live.summary import live_review_summary
 
 console = Console()
@@ -28,19 +28,10 @@ def _status_payload(project_root: Path) -> dict:
         state = StateRepository(session).get_state()
         phase = compute_phase(graph, state.current_phase if state else None)
 
-        total_cost = 0.0
-        log_file = project_root / ".devcouncil" / "logs" / "model_calls.jsonl"
-        if log_file.exists():
-            with open(log_file, "r", encoding="utf-8") as f:
-                for line in f:
-                    try:
-                        entry = json.loads(line)
-                        total_cost += CostEstimator.estimate_cost(
-                            entry.get("response", {}).get("model", ""),
-                            entry.get("usage", {}),
-                        )
-                    except Exception:
-                        continue
+        # Single read of the model-call ledger: derive both the grand total and the
+        # per-task breakdown from one pass (group_cost -> read_cost_records). This is
+        # provider-aware (ollama records are free), matching the Cost-by-Task table.
+        cost = group_cost(project_root)
 
         status_counts: dict[str, int] = {}
         for task in graph.tasks.values():
@@ -50,8 +41,8 @@ def _status_payload(project_root: Path) -> dict:
             "initialized": True,
             "phase": phase,
             "coverage_summary": summary,
-            "total_cost": total_cost,
-            "cost_by_task": cost_by_task(project_root),
+            "total_cost": cost["total_cost"],
+            "cost_by_task": cost["by_task"],
             "task_status_counts": status_counts,
             "blocking_gaps": [gap.model_dump() for gap in blocking_gaps],
             "live_review": live_review_summary(project_root),

package/src/devcouncil/cli/commands/verify.py

@@ -1,6 +1,7 @@
 import typer
 import asyncio
 import json
+import logging
 from rich.console import Console
 from rich.table import Table
 from pathlib import Path
@@ -20,6 +21,7 @@ from devcouncil.integrations.code_review_graph import CodeReviewGraphAdapter
 from devcouncil.telemetry.traces import TraceLogger
 
 console = Console()
+logger = logging.getLogger(__name__)
 MAX_RENDERED_GAPS = 20
 
 
@@ -55,6 +57,9 @@ def verify(
     Verify one task, or all tasks when TASK_ID is omitted.
     """
     root = project_root.expanduser().resolve()
+    from devcouncil.telemetry.logging_setup import set_log_dir
+    set_log_dir(root)
+    logger.info("dev verify: task=%s sandbox=%s", task_id or "ALL", sandbox)
     initialize_project(root, quiet=True)
     db = get_db(root)
     if not db:
@@ -88,7 +93,7 @@ def verify(
             config = load_config(root)
             validate_model_provider(config.models.provider)
             api_key = get_api_key(config.models.provider, root)
-            provider = create_provider(config.models.provider, api_key, project_root=root)
+            provider = create_provider(config.models.provider, api_key, project_root=root, provider_prefs=config.provider)
             role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
             router = ModelRouter(provider, role_config, project_root=root)
         except Exception:
@@ -236,6 +241,7 @@ def verify(
         # against the current tree, so a regression would have failed the test and the AC
         # would not be in proven_acs — this clears only genuinely-satisfied criteria.
         if task_id is None and proven_acs:
+            result_map = {r["task_id"]: r for r in task_results}
             for task in tasks:
                 gaps = per_task_gaps.get(task.id, [])
                 kept = reconcile_cross_task_acceptance(gaps, proven_acs)
@@ -255,15 +261,15 @@ def verify(
                         summary=f"{task.id} verified via cross-task acceptance reconciliation",
                     )
                 task_repo.save(task)
-                for result in task_results:
-                    if result["task_id"] == task.id:
-                        blocking_actions, advisory_actions = split_next_actions(kept)
-                        result["status"] = task.status
-                        result["gap_count"] = len(kept)
-                        result["blocking_gap_count"] = len([gap for gap in kept if gap.blocking])
-                        result["gaps"] = [gap.model_dump() for gap in kept]
-                        result["next_actions"] = [action.model_dump() for action in blocking_actions]
-                        result["advisory_actions"] = [action.model_dump() for action in advisory_actions]
+                if task.id in result_map:
+                    result = result_map[task.id]
+                    blocking_actions, advisory_actions = split_next_actions(kept)
+                    result["status"] = task.status
+                    result["gap_count"] = len(kept)
+                    result["blocking_gap_count"] = len([gap for gap in kept if gap.blocking])
+                    result["gaps"] = [gap.model_dump() for gap in kept]
+                    result["next_actions"] = [action.model_dump() for action in blocking_actions]
+                    result["advisory_actions"] = [action.model_dump() for action in advisory_actions]
 
         StateRepository(session).record_phase(
             ProjectPhase.TASK_BLOCKED.value if blocked_tasks else ProjectPhase.TASK_VERIFIED.value