devcouncil 0.2.0 → 0.3.1

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

@@ -0,0 +1,106 @@
+"""`dev logs` — find and read DevCouncil's runtime logs.
+
+Comprehensive logging only helps if the logs are easy to reach when something
+breaks. This command surfaces the always-on shared log
+(``.devcouncil/logs/devcouncil.log``) and the per-run logs
+(``.devcouncil/runs/<run_id>/run.log``) without the user needing to remember
+paths or hand-roll ``tail``/``grep``.
+"""
+
+import time
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from devcouncil.telemetry.logging_setup import LOG_RELATIVE_PATH
+
+app = typer.Typer(help="View DevCouncil runtime logs (shared and per-run).")
+console = Console()
+
+
+def _shared_log(root: Path) -> Path:
+    return root / LOG_RELATIVE_PATH
+
+
+def _runs_dir(root: Path) -> Path:
+    return root / ".devcouncil" / "runs"
+
+
+def _print_tail(path: Path, limit: int, grep: Optional[str]) -> None:
+    if not path.exists():
+        console.print(f"[yellow]No log at {path}. Run a command first (or pass --project-root).[/yellow]")
+        raise typer.Exit(code=0)
+    # Read only the tail rather than the whole (potentially large, rotated) file.
+    lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+    if grep:
+        lines = [line for line in lines if grep.lower() in line.lower()]
+    for line in lines[-limit:]:
+        console.print(line, markup=False, highlight=False)
+
+
+@app.command("tail")
+def tail(
+    limit: int = typer.Option(50, "--limit", "-n", help="Number of trailing lines to show."),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Keep printing new lines as they are written."),
+    grep: Optional[str] = typer.Option(None, "--grep", "-g", help="Only show lines containing this substring (case-insensitive)."),
+    run: Optional[str] = typer.Option(None, "--run", help="Show a specific run's log (.devcouncil/runs/<run>/run.log) instead of the shared log."),
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """Print the tail of the shared log (or a per-run log with --run)."""
+    root = project_root.expanduser().resolve()
+    path = (_runs_dir(root) / run / "run.log") if run else _shared_log(root)
+
+    _print_tail(path, limit, grep)
+    if not follow:
+        return
+
+    # Follow mode: poll for appended bytes (the file is append-only between rotations).
+    console.print(f"[dim]— following {path} (Ctrl-C to stop) —[/dim]")
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as handle:
+            handle.seek(0, 2)  # jump to EOF; we already printed the tail
+            while True:
+                line = handle.readline()
+                if line:
+                    rendered = line.rstrip("\n")
+                    if not grep or grep.lower() in rendered.lower():
+                        console.print(rendered, markup=False, highlight=False)
+                else:
+                    time.sleep(0.4)
+    except KeyboardInterrupt:  # pragma: no cover - interactive
+        pass
+
+
+@app.command("path")
+def path(
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """Print the shared log file path (and whether it exists)."""
+    root = project_root.expanduser().resolve()
+    log = _shared_log(root)
+    marker = "" if log.exists() else " [yellow](not created yet)[/yellow]"
+    console.print(f"{log}{marker}")
+
+
+@app.command("runs")
+def runs(
+    limit: int = typer.Option(20, "--limit", "-n", help="Maximum number of recent run logs to list."),
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """List per-run logs, newest first, with their paths."""
+    root = project_root.expanduser().resolve()
+    runs_dir = _runs_dir(root)
+    if not runs_dir.exists():
+        console.print("[yellow]No runs yet.[/yellow]")
+        return
+    run_logs = [d / "run.log" for d in runs_dir.iterdir() if (d / "run.log").exists()]
+    if not run_logs:
+        console.print("[yellow]No per-run logs yet (run.log appears once an executor runs).[/yellow]")
+        return
+    run_logs.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    for log in run_logs[:limit]:
+        size_kb = log.stat().st_size / 1024
+        console.print(f"[bold]{log.parent.name}[/bold]  [dim]{log}  ({size_kb:.1f} KB)[/dim]")
+    console.print("\n[dim]View one with:[/dim] dev logs tail --run <run-id>")

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

@@ -0,0 +1,245 @@
+"""`dev okf` — export, ingest, and validate Open Knowledge Format bundles.
+
+* ``dev okf export`` renders DevCouncil's artifact graph as a portable OKF bundle.
+* ``dev okf ingest`` imports an external OKF bundle as planning/coding context under
+  ``.devcouncil/knowledge/okf/`` (selected into prompts like a domain skill).
+* ``dev okf validate`` checks a bundle for the OKF invariants (typed docs, resolved links).
+"""
+
+from __future__ import annotations
+
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from devcouncil.cli.commands.init import initialize_project
+from devcouncil.knowledge.okf import read_bundle, validate_bundle
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import ArtifactGraphRepository
+
+app = typer.Typer(help="Export, ingest, and validate Open Knowledge Format bundles.")
+console = Console()
+
+
+def _knowledge_okf_dir(root: Path) -> Path:
+    from devcouncil.app.config import load_config
+
+    directory = ".devcouncil/knowledge"
+    try:
+        directory = load_config(root).knowledge.directory
+    except Exception:
+        pass
+    return root / directory / "okf"
+
+
+def _knowledge_design_md(root: Path) -> Path | None:
+    """Locate the project's design.md under the configured knowledge dir's design/ subdir.
+
+    Honors the same config dir resolution as :func:`_knowledge_okf_dir`, falling back to the
+    default ``.devcouncil/knowledge/design/design.md``. Returns ``None`` if no design.md exists.
+    """
+    from devcouncil.app.config import load_config
+
+    directory = ".devcouncil/knowledge"
+    try:
+        directory = load_config(root).knowledge.directory
+    except Exception:
+        pass
+    candidates = [
+        root / directory / "design" / "design.md",
+        root / ".devcouncil" / "knowledge" / "design" / "design.md",
+    ]
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+@app.command("export")
+def export(
+    output: Path = typer.Option(Path("okf_bundle"), "--output", "-o", help="Directory to write the OKF bundle into."),
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+    skills: bool = typer.Option(
+        True,
+        "--skills/--no-skills",
+        help="Include the engineering skills library as OKF documents in the bundle.",
+    ),
+    design: bool = typer.Option(
+        True,
+        "--design/--no-design",
+        help="Include the project's design.md (if present) as an OKF document in the bundle.",
+    ),
+):
+    """Export the DevCouncil artifact graph as an OKF bundle."""
+    root = project_root.expanduser().resolve()
+    initialize_project(root, quiet=True)
+    db = get_db(root)
+    if not db:
+        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
+        raise typer.Exit(code=1)
+
+    out_dir = output.expanduser().resolve()
+    with db.get_session() as session:
+        graph = ArtifactGraphRepository(session).load_graph()
+
+    project_name = root.name or "DevCouncil Project"
+    try:
+        from devcouncil.app.config import load_config
+
+        project_name = load_config(root).project.name or project_name
+    except Exception:
+        pass
+
+    # Load the FULL skill set (packaged library + this repo's own skills) so the export is
+    # complete; goal-driven selection would only emit the few skills that match a goal.
+    skill_list: list = []
+    if skills:
+        from devcouncil.skills.registry import load_skills
+
+        skill_list = load_skills(project_root=root)
+
+    # Look for the project's design.md under the configured knowledge dir; silently skip if
+    # absent so export stays useful for projects without a design system.
+    design_obj = None
+    if design:
+        design_md = _knowledge_design_md(root)
+        if design_md is not None:
+            from devcouncil.knowledge.design import parse_design_md
+
+            try:
+                design_obj = parse_design_md(design_md)
+            except Exception:
+                design_obj = None
+
+    timestamp = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    from devcouncil.reporting.okf_bundle_writer import OKFBundleWriter
+
+    written = OKFBundleWriter.generate(
+        graph,
+        out_dir,
+        project_name=project_name,
+        timestamp=timestamp,
+        include_skills=bool(skill_list),
+        skills=skill_list,
+        include_design=design_obj is not None,
+        design=design_obj,
+    )
+    console.print(
+        f"[green]Exported {len(written)} OKF documents to[/green] {out_dir} "
+        f"([cyan]{out_dir / 'index.md'}[/cyan])."
+    )
+    if skill_list:
+        console.print(f"[green]Included {len(skill_list)} engineering skill document(s).[/green]")
+    if design_obj is not None:
+        console.print("[green]Included 1 design system document(s).[/green]")
+
+
+@app.command("ingest")
+def ingest(
+    bundle: str = typer.Argument(
+        ...,
+        help="OKF bundle source: a local directory, a .tar.gz/.tgz/.zip archive, or a git URL.",
+    ),
+    name: str = typer.Option("", "--name", help="Subfolder name under knowledge/okf (defaults to the bundle name)."),
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """Ingest an external OKF bundle as durable planning/coding context.
+
+    The bundle may be a local directory, a local archive (``.tar.gz``/``.tgz``/``.zip``,
+    extracted behind a path-traversal guard), or a git URL (shallow-cloned). After the
+    source is materialized to a local directory, the existing read/validate/copy logic runs
+    unchanged; any temp directory is removed afterwards.
+    """
+    root = project_root.expanduser().resolve()
+
+    from devcouncil.knowledge.fetch import fetch_bundle
+
+    try:
+        fetched = fetch_bundle(bundle)
+    except Exception as exc:
+        console.print(f"[red]Could not fetch bundle[/red] {bundle!r}: {exc}")
+        raise typer.Exit(code=1)
+
+    try:
+        src = fetched.directory
+        if not src.is_dir():
+            console.print(f"[red]Not a directory:[/red] {src}")
+            raise typer.Exit(code=1)
+
+        initialize_project(root, quiet=True)
+        parsed = read_bundle(src)
+        if not parsed.documents:
+            console.print(f"[yellow]No OKF documents (*.md) found in[/yellow] {bundle}")
+            raise typer.Exit(code=1)
+
+        problems = validate_bundle(parsed)
+        if problems:
+            console.print(f"[yellow]Ingesting a bundle with {len(problems)} validation issue(s):[/yellow]")
+            for p in problems[:10]:
+                console.print(f"  - {p}")
+
+        dest = _knowledge_okf_dir(root) / (name or fetched.suggested_name or "bundle")
+        dest.mkdir(parents=True, exist_ok=True)
+        count = 0
+        for md in src.rglob("*.md"):
+            rel = md.relative_to(src)
+            target = dest / rel
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copyfile(md, target)
+            count += 1
+        console.print(
+            f"[green]Ingested {count} OKF document(s) into[/green] {dest}. "
+            "They are now available as planning/coding context."
+        )
+    finally:
+        fetched.cleanup()
+
+
+@app.command("validate")
+def validate(
+    bundle: Path = typer.Argument(..., help="Path to an OKF bundle directory to validate."),
+):
+    """Validate an OKF bundle (every doc typed; every intra-bundle link resolves)."""
+    src = bundle.expanduser().resolve()
+    if not src.is_dir():
+        console.print(f"[red]Not a directory:[/red] {src}")
+        raise typer.Exit(code=1)
+
+    parsed = read_bundle(src)
+    problems = validate_bundle(parsed)
+    if not problems:
+        console.print(f"[green]✓ Valid OKF bundle[/green] — {len(parsed.documents)} document(s), all links resolve.")
+        return
+    console.print(f"[red]✗ {len(problems)} problem(s) in[/red] {src}:")
+    for p in problems:
+        console.print(f"  - {p}")
+    raise typer.Exit(code=1)
+
+
+@app.command("html")
+def html(
+    bundle: Path = typer.Argument(..., help="Path to an OKF bundle directory to render."),
+    output: Path = typer.Option(Path("okf_site"), "--output", "-o", help="Directory to write the static HTML site into."),
+):
+    """Render an OKF bundle as a browsable, self-contained static HTML site."""
+    src = bundle.expanduser().resolve()
+    if not src.is_dir():
+        console.print(f"[red]Not a directory:[/red] {src}")
+        raise typer.Exit(code=1)
+
+    parsed = read_bundle(src)
+    if not parsed.documents:
+        console.print(f"[yellow]No OKF documents (*.md) found in[/yellow] {src}")
+        raise typer.Exit(code=1)
+
+    from devcouncil.reporting.okf_html import write_bundle_html
+
+    out_dir = output.expanduser().resolve()
+    written = write_bundle_html(parsed, out_dir)
+    console.print(
+        f"[green]Rendered {len(written)} page(s) to[/green] {out_dir} "
+        f"([cyan]{out_dir / 'index.html'}[/cyan])."
+    )

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

@@ -2,6 +2,7 @@ import typer
 import asyncio
 import json
 import datetime
+import logging
 from typing import Any
 from rich.console import Console
 from rich.panel import Panel
@@ -18,8 +19,8 @@ from devcouncil.integrations.code_review_graph import CodeReviewGraphAdapter
 from devcouncil.llm.provider import Provider, MockProvider, ProviderRequestError, build_role_model_config, create_provider, validate_model_provider
 from devcouncil.llm.router import ModelRouter, StructuredOutputError
 from devcouncil.planning.spec_service import SpecService
-from devcouncil.planning.prompt_enhancer_service import PromptEnhancerService
-from devcouncil.planning.plan_service import PlanService
+from devcouncil.planning.prompt_enhancer_service import PromptEnhancerService, save_active_prompt_enhancement
+from devcouncil.planning.plan_service import PlanService, backfill_acceptance_criteria
 from devcouncil.planning.critique_service import CritiqueService
 from devcouncil.planning.arbiter_service import ArbiterDecision, ArbiterService
 from devcouncil.gating.policy import GatePolicy
@@ -28,9 +29,11 @@ from devcouncil.app.state_machine import ProjectPhase
 from devcouncil.app.config import ModelRoleConfig, load_config, get_api_key
 from devcouncil.cli.commands.init import initialize_project
 from devcouncil.telemetry.traces import TraceLogger
+from devcouncil.telemetry.stages import log_step
 
 app = typer.Typer()
 console = Console()
+logger = logging.getLogger(__name__)
 
 REQUIRED_PLANNING_ROLES = (
     "prompt_enhancer",
@@ -92,6 +95,8 @@ async def run_plan_flow(
     quick: bool = False,
 ):
     root = project_root.expanduser().resolve()
+    from devcouncil.telemetry.logging_setup import set_log_dir
+    set_log_dir(root)
     initialize_project(root, quiet=True)
     db = get_db(root)
     if not db:
@@ -166,7 +171,7 @@ async def run_plan_flow(
         if api_key is None:
             console.print("[red]Missing API key for configured model provider.[/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)
 
     # Build role config after dry-run overrides so mocks are routed correctly.
     role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
@@ -185,16 +190,20 @@ async def run_plan_flow(
         transient=True,
     ) as progress:
         # 1. Repo Map
+        log_step("plan/1: mapping repository", project_root=root, run_id=run_id)
         progress.add_task(description="Mapping repository...", total=None)
         repo_map = mapper.map_repo(goal)
         repo_map_json = repo_map.model_dump_json(indent=2)
-        orchestrator.save_run_artifact("repo_map.json", json.loads(repo_map_json))
+        # save_run_artifact re-serializes via json.dump, so pass the dict directly
+        # instead of round-tripping the already-serialized JSON back through json.loads.
+        orchestrator.save_run_artifact("repo_map.json", repo_map.model_dump(mode="json"))
         graph_context = CodeReviewGraphAdapter(root).get_context()
         if graph_context.available:
             orchestrator.save_run_artifact("code_review_graph_context.json", graph_context.model_dump())
         await orchestrator.transition_to(ProjectPhase.REPO_MAPPED)
 
         # 2. Codebase-specific prompt enhancement
+        log_step("plan/2: enhancing prompt for codebase debate", project_root=root, run_id=run_id)
         progress.add_task(description="Enhancing prompt for codebase debate...", total=None)
         prompt_enhancement = await prompt_enhancer.enhance_prompt(
             goal,
@@ -225,6 +234,7 @@ async def run_plan_flow(
         )
 
         # 3. Spec / Requirements
+        log_step("plan/3: generating requirements", project_root=root, run_id=run_id)
         progress.add_task(description="Generating requirements...", total=None)
         spec_output = await spec_service.generate_spec(debate_goal, repo_map_json)
         orchestrator.save_run_artifact("requirements.json", spec_output.model_dump())
@@ -243,6 +253,7 @@ async def run_plan_flow(
             # adversarial robustness for ~5 fewer model calls — the right setting
             # for small, well-scoped changes where verification (which still gates
             # every diff) is the real safety net, not planning debate.
+            log_step("plan/4: generating single plan (quick mode)", project_root=root, run_id=run_id)
             progress.add_task(description="Generating single plan (quick mode)...", total=None)
             plan_a = await plan_service.generate_plan(
                 "planner_a", debate_goal, requirements_json, repo_map_json
@@ -266,6 +277,7 @@ async def run_plan_flow(
             final_tasks = [task.model_copy(update={"status": "planned"}) for task in decision.final_tasks]
         else:
             # 4. Independent Plans (run concurrently — they don't depend on each other)
+            log_step("plan/4: generating Plans A (pragmatic) and B (robust)", project_root=root, run_id=run_id)
             progress.add_task(description="Generating Plans A (Pragmatic) and B (Robust)...", total=None)
             plan_a, plan_b = await asyncio.gather(
                 plan_service.generate_plan("planner_a", debate_goal, requirements_json, repo_map_json),
@@ -275,34 +287,44 @@ async def run_plan_flow(
             orchestrator.save_run_artifact("plan_b.json", plan_b.model_dump())
             await orchestrator.transition_to(ProjectPhase.PLANS_GENERATED)
 
+            # Serialize each plan/critique once and reuse the strings across the
+            # critique, rebuttal, and arbitration steps below.
+            plan_a_json = plan_a.model_dump_json()
+            plan_b_json = plan_b.model_dump_json()
+
             # 5. Cross-Critique (independent — run concurrently)
+            log_step("plan/5: cross-critiquing Plans A and B", project_root=root, run_id=run_id)
             progress.add_task(description="Critiquing Plans A and B...", total=None)
             critique_a, critique_b = await asyncio.gather(
-                critique_service.generate_critique("critic_a", plan_b.model_dump_json(), requirements_json),
-                critique_service.generate_critique("critic_b", plan_a.model_dump_json(), requirements_json),
+                critique_service.generate_critique("critic_a", plan_b_json, requirements_json),
+                critique_service.generate_critique("critic_b", plan_a_json, requirements_json),
             )
             orchestrator.save_run_artifact("critique_a.json", critique_a.model_dump())
             orchestrator.save_run_artifact("critique_b.json", critique_b.model_dump())
             await orchestrator.transition_to(ProjectPhase.CRITIQUES_GENERATED)
+            critique_a_json = critique_a.model_dump_json()
+            critique_b_json = critique_b.model_dump_json()
 
             # 6. Rebuttals (independent — run concurrently)
+            log_step("plan/6: generating rebuttals", project_root=root, run_id=run_id)
             progress.add_task(description="Generating rebuttals...", total=None)
             rebuttal_a, rebuttal_b = await asyncio.gather(
-                critique_service.generate_rebuttal("planner_a", plan_a.model_dump_json(), critique_b.model_dump_json()),
-                critique_service.generate_rebuttal("planner_b", plan_b.model_dump_json(), critique_a.model_dump_json()),
+                critique_service.generate_rebuttal("planner_a", plan_a_json, critique_b_json),
+                critique_service.generate_rebuttal("planner_b", plan_b_json, critique_a_json),
             )
             orchestrator.save_run_artifact("rebuttal_a.json", rebuttal_a.model_dump())
             orchestrator.save_run_artifact("rebuttal_b.json", rebuttal_b.model_dump())
 
             # 7. Arbitration
+            log_step("plan/7: arbitrating final plan", project_root=root, run_id=run_id)
             progress.add_task(description="Arbitrating final plan...", total=None)
             decision = await arbiter_service.arbitrate(
                 debate_goal,
-                json.dumps([r.model_dump() for r in spec_output.requirements]),
-                plan_a.model_dump_json(),
-                plan_b.model_dump_json(),
-                critique_a.model_dump_json(),
-                critique_b.model_dump_json(),
+                requirements_json,
+                plan_a_json,
+                plan_b_json,
+                critique_a_json,
+                critique_b_json,
                 rebuttal_a.model_dump_json(),
                 rebuttal_b.model_dump_json()
             )
@@ -317,10 +339,23 @@ async def run_plan_flow(
         console.print("[blue](DRY RUN: No actual LLM calls were made)[/blue]")
         if not persist:
             console.print("[blue](DRY RUN: Final requirements/tasks were not persisted)[/blue]")
+    # Operationalize the spec's edge-case elaboration: attach every acceptance criterion
+    # the planner left unlinked to a task that owns its requirement, so elaborated edges
+    # (truncation semantics, error paths, boundaries) are actually built and per-criterion
+    # verified instead of silently dropped — the gap that lets a gated run be no better
+    # than the raw prompt.
+    final_tasks, backfilled_acs = backfill_acceptance_criteria(final_tasks, decision.final_requirements)
+    if backfilled_acs:
+        console.print(
+            f"[dim]Linked {len(backfilled_acs)} unmapped acceptance criterion(s) to owning task(s) "
+            "so every elaborated behavior is verified.[/dim]"
+        )
+
     console.print(f"Final Requirements: [bold]{len(decision.final_requirements)}[/bold]")
     console.print(f"Final Tasks: [bold]{len(final_tasks)}[/bold]")
-    
+
     # 8. Check Gates
+    log_step("plan/8: checking plan-approval gates", project_root=root, run_id=run_id)
     policy = GatePolicy()
     result = policy.check_plan_approval(
         decision.final_requirements,
@@ -342,8 +377,12 @@ async def run_plan_flow(
                     final_tasks,
                     reconciled_findings,
                 )
+            # Pin THIS plan's enhancement so the executor reads the domain guidance tied to
+            # the plan it runs (not a later run's by mtime).
+            save_active_prompt_enhancement(root, prompt_enhancement)
 
         console.print("[green]Plan approved by gates.[/green]")
+        logger.info("Plan approved by gates: %d task(s)", len(final_tasks))
         await orchestrator.transition_to(ProjectPhase.PLAN_APPROVED)
         return [task.id for task in final_tasks]
     else:
@@ -353,6 +392,7 @@ async def run_plan_flow(
                 for gap in result.gaps:
                     gap_repo.save(gap)
         console.print("[yellow]Plan generated but failed gates. See status for gaps.[/yellow]")
+        logger.warning("Plan failed approval gates with %d gap(s)", len(result.gaps))
         await orchestrator.transition_to(ProjectPhase.AWAITING_USER_DECISIONS)
         return []
 

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

@@ -9,13 +9,17 @@ from devcouncil.llm.router import ModelRouter
 from devcouncil.app.config import load_config, get_api_key
 from devcouncil.cli.commands.init import initialize_project
 import asyncio
+import logging
 from pathlib import Path
 
 app = typer.Typer()
 console = Console()
+logger = logging.getLogger(__name__)
 
 async def run_repair_flow(project_root: Path = Path(".")):
     root = project_root.expanduser().resolve()
+    from devcouncil.telemetry.logging_setup import set_log_dir
+    set_log_dir(root)
     initialize_project(root, quiet=True)
     db = get_db(root)
     if not db:
@@ -28,25 +32,29 @@ async def run_repair_flow(project_root: Path = Path(".")):
 
         all_gaps = gap_repo.get_all()
         blocking_gaps = [g for g in all_gaps if g.blocking]
-        
+
         if not blocking_gaps:
+            logger.info("dev repair: no blocking gaps; nothing to repair")
             console.print("[green]No blocking gaps found. Nothing to repair![/green]")
             return
 
+        logger.info("dev repair: %d blocking gap(s) across %d task(s)", len(blocking_gaps), len({g.task_id for g in blocking_gaps if g.task_id}))
         console.print(f"Found [bold]{len(blocking_gaps)}[/bold] blocking gaps. Orchestrating repair plan...")
 
         # Load router when credentials are available. Correction manifests have a
         # deterministic fallback path, so missing model credentials must not block
         # repair artifact generation.
         repair_service = None
+        config = None
         try:
             config = load_config(root)
             validate_model_provider(config.models.provider)
             api_key = get_api_key(config.models.provider, root)
         except (FileNotFoundError, ValueError) as e:
+            logger.warning("dev repair: no LLM provider (%s); using deterministic manifest fallback", e)
             console.print(f"[yellow]{e}[/yellow]")
         else:
-            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)
             repair_service = RepairService(router)
@@ -60,7 +68,7 @@ async def run_repair_flow(project_root: Path = Path(".")):
         task_ids = {gap.task_id for gap in blocking_gaps if gap.task_id}
         for scoped_task_id in task_ids:
             if scoped_task_id:
-                path = write_correction_manifest(root, scoped_task_id, repair_service=repair_service)
+                path = write_correction_manifest(root, scoped_task_id, repair_service=repair_service, config=config)
                 if path:
                     console.print(f"  - Wrote correction manifest [dim]{path}[/dim]")
 
@@ -73,6 +81,7 @@ async def run_repair_flow(project_root: Path = Path(".")):
                 repair_count += 1
                 console.print(f"  - Created intelligent repair task [bold]{task.id}[/bold]: {task.title}")
 
+        logger.info("dev repair complete: generated %d repair task(s)", repair_count)
         console.print(f"\n[green]Successfully generated {repair_count} repair tasks.[/green]")
 
 @app.callback(invoke_without_command=True)