devcouncil 0.1.0 → 0.2.0

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

@@ -0,0 +1,69 @@
+import json
+from typing import NoReturn
+
+import typer
+from pathlib import Path
+from rich.console import Console
+
+from devcouncil.cli.commands.init import initialize_project
+from devcouncil.execution.handoff import HandoffService
+from devcouncil.executors.agent_registry import load_cli_agent_specs, normalize_agent_name
+
+console = Console()
+
+
+def handoff(
+    task_id: str = typer.Argument(...),
+    from_agent: str = typer.Option(..., "--from"),
+    to_agent: str = typer.Option(..., "--to"),
+    instruction: str = typer.Option("", "--instruction"),
+    json_format: bool = typer.Option(False, "--json", help="Output machine-readable JSON the agent can chain on."),
+    project_root: Path = typer.Option(Path("."), "--project-root"),
+):
+    """
+    Hand off a task between coding CLI agents.
+    """
+    def _fail(message: str) -> NoReturn:
+        if json_format:
+            typer.echo(json.dumps({"ok": False, "task_id": task_id, "error": message}, indent=2))
+        else:
+            console.print(f"[red]{message}[/red]")
+        raise typer.Exit(code=1)
+
+    root = project_root.expanduser().resolve()
+    initialize_project(root, quiet=True)
+    specs = load_cli_agent_specs(root)
+    from_name = normalize_agent_name(from_agent)
+    to_name = normalize_agent_name(to_agent)
+    if from_name not in specs or to_name not in specs:
+        _fail("Unknown agent name. Use dev agents list.")
+
+    try:
+        manifest, path, run_id = HandoffService(root).create(
+            task_id,
+            from_name,
+            to_name,
+            instruction=instruction,
+        )
+    except ValueError as exc:
+        _fail(str(exc))
+
+    next_command = f"dev run {task_id} --executor {to_name}"
+    if json_format:
+        typer.echo(json.dumps({
+            "ok": True,
+            "task_id": task_id,
+            "from": from_name,
+            "to": to_name,
+            "manifest_path": str(path),
+            "run_id": run_id,
+            "next_command": next_command,
+        }, indent=2))
+        return
+
+    console.print(f"[green]Handoff manifest:[/green] {path}")
+    console.print(f"[cyan]Next:[/cyan] {next_command}")
+    console.print(f"[dim]Run artifacts: .devcouncil/runs/{run_id}[/dim]")
+    if instruction:
+        console.print(f"[dim]Instruction: {instruction}[/dim]")
+    _ = manifest

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

@@ -7,55 +7,231 @@ from rich.console import Console
 from devcouncil.storage.db import get_db
 from devcouncil.storage.repositories import TaskRepository
 from devcouncil.execution.hook_policy import HookPolicy
+from devcouncil.telemetry.traces import TraceLogger
+from devcouncil.live.signals import write_signal
+from devcouncil.live.tasks import active_task_id
 
 app = typer.Typer()
 console = Console()
 
 
-def _project_root() -> Path:
+def _project_root(project_root: Path | None = None) -> Path:
+    if project_root:
+        return project_root.expanduser().resolve()
     configured = os.environ.get("DEVCOUNCIL_PROJECT_ROOT")
     return Path(configured).expanduser().resolve() if configured else Path(".").resolve()
-
+
+
+def _active_task(root: Path):
+    # Resolve the *single* unambiguous running task. active_task_id returns None when
+    # zero or multiple tasks are running, so we never authorize a write against the
+    # wrong task; the policy engine then denies for task=None (fail-closed).
+    active_id = active_task_id(root)
+    if not active_id:
+        return None
+    db = get_db(root)
+    if not db:
+        return None
+    with db.get_session() as session:
+        return TaskRepository(session).get_by_id(active_id)
+
+
+def _emit_decision(client: str, action: str, reason: str) -> None:
+    if action == "deny":
+        print(reason, file=sys.stderr)
+        raise typer.Exit(code=2)
+
+    if client in {"codex", "gemini"}:
+        payload = {"decision": "allow", "reason": reason, "suppressOutput": True}
+        if action == "warn":
+            payload["systemMessage"] = f"DevCouncil Warning: {reason}"
+        print(json.dumps(payload, separators=(",", ":")))
+        return
+
+    if action == "warn":
+        console.print(f"[yellow]DevCouncil Warning:[/yellow] {reason}")
+
+
+def _emit_unevaluable(client: str, reason: str, strict: bool, *, action: str = "warn") -> None:
+    """Decide what to do when a tool call cannot be evaluated (empty/malformed/error).
+
+    Fail-closed in strict mode (block), otherwise surface a warning but allow — and
+    never leak an undefined exit code, which would silently disable the only pre-action
+    gate."""
+    _emit_decision(client, "deny" if strict else action, f"{reason}{' (strict mode: blocking)' if strict else ''}")
+
+
 @app.command()
 def pre_tool_use(
-    tool_call_json: str | None = typer.Argument(None, help="The JSON string of the tool call from Claude Code")
+    tool_call_json: str | None = typer.Argument(None, help="The JSON string of the tool call from the coding CLI."),
+    client: str = typer.Option("claude", "--client", help="Hook client: claude, codex, gemini, cursor, or generic."),
+    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
+    strict: bool = typer.Option(
+        False,
+        "--strict",
+        envvar="DEVCOUNCIL_HOOK_STRICT",
+        help="Fail closed (block) when a tool call cannot be parsed or evaluated.",
+    ),
 ):
-    """
-    Claude Code hook: Inspects a tool call before execution.
+    """
+    Coding CLI hook: Inspects a tool call before execution.
     Exits with code 2 to block unauthorized file writes.
     """
+    normalized_client = client.lower()
     try:
         if tool_call_json is None:
             tool_call_json = sys.stdin.read()
+        # Empty payload: nothing to evaluate. Benign in normal use, so allow — but make
+        # it observable, and block under --strict.
         if not tool_call_json.strip():
-            raise typer.Exit(code=0)
-        call_data = json.loads(tool_call_json)
-        active_task = None
-        root = _project_root()
-        db = get_db(root)
-        if db:
-            with db.get_session() as session:
-                task_repo = TaskRepository(session)
-                running_tasks = [t for t in task_repo.get_all() if t.status == "running"]
-                active_task = running_tasks[0] if running_tasks else None
+            return _emit_unevaluable(normalized_client, "Empty tool-call payload; nothing to evaluate.", strict, action="allow")
+        try:
+            call_data = json.loads(tool_call_json)
+        except json.JSONDecodeError:
+            # A real tool call we cannot parse must not silently pass the gate.
+            return _emit_unevaluable(normalized_client, "Tool-call payload was not valid JSON; could not enforce policy.", strict)
+        root = _project_root(project_root)
+        active_task = _active_task(root)
 
         decision = HookPolicy(project_root=root).evaluate(call_data, active_task)
-        if decision.action == "deny":
-            console.print(f"[red]DevCouncil Blocked Action:[/red] {decision.reason}")
-            sys.exit(2)
-        if decision.action == "warn":
-            console.print(f"[yellow]DevCouncil Warning:[/yellow] {decision.reason}")
-                
+        _emit_decision(normalized_client, decision.action, decision.reason)
+    except typer.Exit:
+        raise
+    except Exception as exc:  # never emit an undefined exit code from a crashing hook
+        return _emit_unevaluable(normalized_client, f"Hook error: {exc}", strict)
+
+@app.command()
+def post_tool_use(
+    tool_call_json: str | None = typer.Argument(None, help="The JSON string of the completed tool call."),
+    client: str = typer.Option("claude", "--client", help="Hook client: claude, codex, gemini, cursor, or generic."),
+    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """
+    Coding CLI hook: Records a post-tool-use checkpoint for native hook clients.
+    """
+    _ = tool_call_json if tool_call_json is not None else sys.stdin.read()
+    _ = _project_root(project_root)
+    if client.lower() in {"codex", "gemini"}:
+        print(json.dumps({"decision": "allow", "suppressOutput": True}, separators=(",", ":")))
+
+@app.command()
+def agent_response(
+    event_json: str | None = typer.Argument(None, help="The JSON hook payload from the coding CLI."),
+    client: str = typer.Option("claude", "--client", help="Hook client: claude, codex, gemini, cursor, or generic."),
+    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """
+    Coding CLI hook: records that an agent response is ready for DevCouncil watch review.
+    """
+    payload_text = event_json if event_json is not None else sys.stdin.read()
+    root = _project_root(project_root)
+    try:
+        payload = json.loads(payload_text) if payload_text.strip() else {}
     except json.JSONDecodeError:
-        raise typer.Exit(code=0)
-
-@app.command()
-def post_task():
-    """
-    Claude Code hook: Runs after a task is completed.
-    Triggers deterministic verification.
-    """
-    console.print("[cyan]DevCouncil: Claude finished task. Triggering automatic verification...[/cyan]")
-    # In a real environment, this would invoke 'dev verify <active-task>'
-    # For the hook script, we just notify the user.
-    console.print("Run [bold]dev verify[/bold] to finalize implementation evidence.")
+        payload = {"raw": payload_text}
+    if isinstance(payload, dict) and not any(key in payload for key in ("task_id", "taskId", "task")):
+        active_id = active_task_id(root)
+        if active_id:
+            payload["task_id"] = active_id
+    signal_path = write_signal(root, client.lower(), payload)
+    TraceLogger(root).log_event(
+        "agent_response_ready",
+        {"client": client.lower(), "signal": str(signal_path)},
+        summary=f"{client} response ready for critique-card review.",
+    )
+    if client.lower() in {"codex", "gemini"}:
+        print(json.dumps({"decision": "allow", "suppressOutput": True}, separators=(",", ":")))
+
+@app.command()
+def post_task(
+    client: str = typer.Option("claude", "--client", help="Hook client: claude, codex, gemini, cursor, or generic."),
+    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """
+    Coding CLI hook: Runs after a task is completed.
+
+    When ``execution.verify_on_post_task`` is enabled, this runs deterministic
+    verification of the active task and records gaps; otherwise it just reminds the
+    user to run ``dev verify`` (the default, to keep hooks fast/cheap).
+    """
+    root = _project_root(project_root)
+    try:
+        from devcouncil.app.config import load_config
+        verify_enabled = load_config(root).execution.verify_on_post_task
+    except Exception:
+        verify_enabled = False
+
+    if not verify_enabled:
+        console.print("[cyan]DevCouncil: coding agent finished task.[/cyan]")
+        console.print("Run [bold]dev verify[/bold] to finalize implementation evidence.")
+        _emit_post_task_allow(client)
+        return
+
+    summary = _verify_active_task(root)
+    console.print(summary)
+    _emit_post_task_allow(client)
+
+
+def _emit_post_task_allow(client: str) -> None:
+    if client.lower() in {"codex", "gemini"}:
+        print(json.dumps({"decision": "allow", "suppressOutput": True}, separators=(",", ":")))
+
+
+def _verify_active_task(root: Path) -> str:
+    """Run deterministic verification of the active task and persist gaps/evidence.
+    Returns a human summary line. Best-effort: never raises out of a hook."""
+    try:
+        import asyncio
+
+        from devcouncil.domain.evidence import CommandResult, DiffCoverageEvidence, DiffEvidence, TestEvidence
+        from devcouncil.storage.repositories import (
+            EvidenceRepository,
+            GapRepository,
+            RequirementRepository,
+        )
+        from devcouncil.verification.next_actions import split_next_actions
+        from devcouncil.verification.verifier import Verifier
+
+        active_id = active_task_id(root)
+        db = get_db(root)
+        if not active_id or not db:
+            return "Run [bold]dev verify[/bold] to finalize implementation evidence."
+        with db.get_session() as session:
+            task = TaskRepository(session).get_by_id(active_id)
+            if not task:
+                return "Run [bold]dev verify[/bold] to finalize implementation evidence."
+            reqs = RequirementRepository(session).get_all()
+            gaps, evidence = asyncio.run(Verifier(root).verify_task(task, reqs))
+            gap_repo = GapRepository(session)
+            ev_repo = EvidenceRepository(session)
+            gap_repo.delete_for_task(task.id)
+            ev_repo.delete_for_task(task.id)
+            for gap in gaps:
+                gap_repo.save(gap)
+            for ev in evidence:
+                if isinstance(ev, CommandResult):
+                    ev_repo.save_command_result(task.id, ev)
+                elif isinstance(ev, DiffCoverageEvidence):
+                    ev_repo.save_diff_coverage_evidence(ev)
+                elif isinstance(ev, DiffEvidence):
+                    ev_repo.save_diff_evidence(ev)
+                elif isinstance(ev, TestEvidence):
+                    ev_repo.save_test_evidence(ev, task.id)
+            blocking = [g for g in gaps if g.blocking]
+            task.status = "blocked" if blocking else "verified"
+            TaskRepository(session).save(task)
+        blocking_actions, _ = split_next_actions(gaps)
+        TraceLogger(root).log_event(
+            "post_task_verified",
+            {"task_id": active_id, "blocking": len(blocking)},
+            task_id=active_id,
+            summary=f"post_task verification: {task.status}",
+        )
+        if blocking:
+            return (
+                f"[yellow]{active_id} is blocked by {len(blocking)} gap(s); "
+                f"{len(blocking_actions)} next action(s). Run [bold]dev repair[/bold].[/yellow]"
+            )
+        return f"[green]{active_id} verified.[/green]"
+    except Exception as exc:  # never let a hook crash the agent
+        return f"[dim]post-task verification skipped: {exc}[/dim]"

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

@@ -1,52 +1,79 @@
-import copy
-import typer
-import yaml
-from rich.console import Console
-from pathlib import Path
-from devcouncil.storage.db import Database
-from devcouncil.integrations.gitnexus import GitNexusIntegration
-from devcouncil.integrations.graphify import GraphifyIntegration
-
-app = typer.Typer()
-console = Console()
-
+import copy
+from typing import Any
+import typer
+import yaml
+from rich.console import Console
+from pathlib import Path
+from devcouncil.storage.db import Database
+from devcouncil.integrations.gitnexus import GitNexusIntegration
+from devcouncil.integrations.graphify import GraphifyIntegration
+from devcouncil.llm.provider import build_role_model_config, validate_model_provider
+from devcouncil.repo.gitignore import ensure_gitignore
+
+app = typer.Typer()
+console = Console()
+
+# Per-stack default verification commands. A fresh project gets ONLY the commands
+# for the stack(s) actually detected in the repo, so the verifier never inherits a
+# cross-stack gate (e.g. `npm test`/`eslint`/`tsc` on a Python repo) that it would run
+# as a blocking fallback and fail for tooling/stack reasons instead of a real defect.
+_STACK_COMMAND_DEFAULTS: dict[str, dict[str, list[str]]] = {
+    "python": {"test": ["pytest"], "lint": ["ruff check ."], "typecheck": ["mypy ."]},
+    "node": {"test": ["npm test"], "lint": ["eslint ."], "typecheck": ["tsc --noEmit"]},
+}
+
+
+def _stack_aware_commands(project_root: Path) -> dict[str, list[str]]:
+    """Default test/lint/typecheck commands scoped to the repo's detected stack(s).
+
+    Returns empty lists when no stack is detected — empty is safe (no speculative
+    fallback gates) and far better than guessing wrong-stack tools."""
+    from devcouncil.repo.ci_scaffold import detect_stacks
+
+    commands: dict[str, list[str]] = {"test": [], "lint": [], "typecheck": []}
+    try:
+        stacks = detect_stacks(project_root)
+    except Exception:
+        return commands
+    for stack in sorted(stacks):
+        for key, cmds in _STACK_COMMAND_DEFAULTS.get(stack, {}).items():
+            for command in cmds:
+                if command not in commands[key]:
+                    commands[key].append(command)
+    return commands
+
+
 DEFAULT_CONFIG = {
-    "project": {
-        "name": "devcouncil-project",
-        "root": ".",
-        "default_branch": "main",
-    },
-    "models": {
-        "provider": "openrouter",
-        "roles": {
-            "spec_writer": {"model": "anthropic/claude-3.5-sonnet"},
-            "planner_a": {"model": "anthropic/claude-3.5-sonnet"},
-            "planner_b": {"model": "google/gemini-pro-1.5"},
-            "critic_a": {"model": "openai/gpt-4o"},
-            "critic_b": {"model": "anthropic/claude-3-opus"},
-            "arbiter": {"model": "openai/gpt-4o"},
-            "native_agent": {"model": "anthropic/claude-3.5-sonnet"},
-            "implementation_reviewer": {"model": "openai/gpt-4o"},
-        }
-    },
-    "commands": {
-        "test": ["pytest", "npm test"],
-        "lint": ["flake8", "eslint"],
-        "typecheck": ["mypy", "tsc"]
-    },
-    "gates": {
-        "require_clean_git_before_task": True,
-        "block_orphan_diffs": True,
-        "block_missing_tests_for_high_requirements": True,
-        "block_dependency_changes_without_approval": True,
-        "block_schema_change_without_migration": True,
-        "block_failed_commands": True
-    },
-    "execution": {
-        "default_executor": "native",
-        "max_repair_attempts": 3,
-        "checkpoint_before_each_task": True
-    },
+    "project": {
+        "name": "devcouncil-project",
+        "root": ".",
+        "default_branch": "main",
+    },
+    "models": {
+        "provider": "openrouter",
+        "roles": build_role_model_config("openrouter"),
+    },
+    "commands": {
+        "test": [],
+        "lint": [],
+        "typecheck": [],
+    },
+    "gates": {
+        "require_clean_git_before_task": True,
+        "block_orphan_diffs": True,
+        "block_missing_tests_for_high_requirements": True,
+        "block_dependency_changes_without_approval": True,
+        "block_schema_change_without_migration": True,
+        "block_failed_commands": True
+    },
+    "execution": {
+        "default_executor": "manual",
+        "max_repair_attempts": 3,
+        "checkpoint_before_each_task": True,
+        "stream_cli_output": False,
+        "cursor_resume_mode": "off",
+        "coding_cli_probe_order": [],
+    },
     "privacy": {
         "redact_env_vars": True,
         "redact_secrets_in_logs": True,
@@ -63,15 +90,97 @@ DEFAULT_CONFIG = {
             "command": "code-review-graph",
             "optional": True,
         },
+        "live_review": {
+            "enabled": True,
+            "cards_path": ".devcouncil/live/cards",
+            "signals_path": ".devcouncil/live/signals",
+            "default_client": "claude",
+        },
+        "cli_agents": {
+            "enabled": True,
+            "profiles": {
+                "default": {
+                    "description": "Balanced local execution with DevCouncil verification.",
+                },
+                "yolo": {
+                    "description": "Faster local execution; DevCouncil still verifies the final diff.",
+                    "timeout_seconds": 3600,
+                    "prompt_preamble": "Profile: yolo. Move efficiently within the task scope.",
+                },
+                "prod": {
+                    "description": "Restrictive execution for high-risk repositories.",
+                    "timeout_seconds": 1800,
+                    "prompt_preamble": "Profile: prod. Keep edits minimal and explicitly within task scope.",
+                    "require_explicit_confirmation": True,
+                },
+            },
+            "agents": {},
+        },
     }
 }
 
 
+def parse_role_model_overrides(values: list[str] | None) -> dict[str, str]:
+    overrides: dict[str, str] = {}
+    for value in values or []:
+        if "=" not in value:
+            raise ValueError(f"Invalid --role-model value '{value}'. Use ROLE=MODEL.")
+        role, model = value.split("=", 1)
+        role = role.strip()
+        model = model.strip()
+        if not role or not model:
+            raise ValueError(f"Invalid --role-model value '{value}'. Use ROLE=MODEL.")
+        overrides[role] = model
+    return overrides
+
+
+def _generate_initial_map(project_root: Path, quiet: bool) -> None:
+    """Best-effort repo map + agent guide generation on fresh init.
+
+    Imported lazily to avoid a circular import with the map command, and wrapped
+    so a mapping failure never blocks initialization.
+    """
+    try:
+        from devcouncil.cli.commands.map import generate_map_artifacts
+
+        generate_map_artifacts(project_root, project_root / ".devcouncil" / "repo_map.json")
+        if not quiet:
+            console.print("[green]Generated .devcouncil/repo_map.json and agent guides (AGENTS.md, CLAUDE.md).[/green]")
+    except Exception as exc:  # mapping is best-effort, never fatal
+        if not quiet:
+            console.print(f"[yellow]Skipped repo map generation: {exc}. Run 'dev map' later.[/yellow]")
+
+
+def _scaffold_initial_skills(project_root: Path, quiet: bool) -> None:
+    """Best-effort scaffolding of applicable engineering skills into .claude/skills/.
+
+    Always writes the core-engineering skill; adds domain skills (android, ios, web,
+    ...) whose file triggers match the repository. Never fatal.
+    """
+    try:
+        from devcouncil.skills.registry import scaffold_skills, select_skills
+
+        selected = select_skills(project_root=project_root)
+        written = scaffold_skills(project_root, selected)
+        if written and not quiet:
+            names = ", ".join(sorted(skill.name for skill in selected))
+            console.print(f"[green]Scaffolded {len(written)} skill(s) into .claude/skills/ ({names}).[/green]")
+    except Exception as exc:  # skill scaffolding is best-effort, never fatal
+        if not quiet:
+            console.print(f"[yellow]Skipped skill scaffolding: {exc}. Run 'dev skills scaffold' later.[/yellow]")
+
+
 def initialize_project(
     project_root: Path = Path("."),
     project_name: str | None = None,
+    model_provider: str = "openrouter",
+    model: str | None = None,
+    role_models: dict[str, str] | None = None,
     with_gitnexus: bool = False,
     with_graphify: bool = False,
+    with_map: bool = True,
+    with_skills: bool = True,
+    quiet: bool = False,
 ) -> bool:
     """Initialize DevCouncil project state.
 
@@ -82,7 +191,8 @@ def initialize_project(
     created = False
 
     if not dev_dir.exists():
-        console.print("Initializing DevCouncil...")
+        if not quiet:
+            console.print("Initializing DevCouncil...")
         dev_dir.mkdir(exist_ok=True)
         (dev_dir / "runs").mkdir(exist_ok=True)
         (dev_dir / "cache").mkdir(exist_ok=True)
@@ -90,20 +200,35 @@ def initialize_project(
         (dev_dir / "logs").mkdir(exist_ok=True)
 
         config_path = dev_dir / "config.yaml"
-        config = copy.deepcopy(DEFAULT_CONFIG)
+        config: dict[str, Any] = copy.deepcopy(DEFAULT_CONFIG)
+        # Scope default verification commands to the repo's actual stack(s).
+        config["commands"] = _stack_aware_commands(project_root)
         if project_name:
             config["project"]["name"] = project_name
         else:
             config["project"]["name"] = project_root.name
+        provider = validate_model_provider(model_provider)
+        config["models"]["provider"] = provider
+        config["models"]["roles"] = build_role_model_config(
+            provider,
+            model=model,
+            role_models=role_models,
+        )
 
         with open(config_path, "w") as f:
             yaml.dump(config, f, default_flow_style=False)
 
         db = Database(dev_dir / "state.sqlite")
         db.create_db_and_tables()
-        console.print(f"[green]Successfully initialized DevCouncil in {dev_dir}[/green]")
+        if not quiet:
+            console.print(f"[green]Successfully initialized DevCouncil in {dev_dir}[/green]")
         created = True
 
+        if with_map:
+            _generate_initial_map(project_root, quiet)
+        if with_skills:
+            _scaffold_initial_skills(project_root, quiet)
+
     if with_gitnexus:
         nexus = GitNexusIntegration(project_root)
         nexus.initialize()
@@ -112,17 +237,27 @@ def initialize_project(
         graphify = GraphifyIntegration(project_root)
         graphify.initialize()
 
+    ensure_gitignore(project_root)
     return created
 
 
 @app.callback(invoke_without_command=True)
 def init(
-    ctx: typer.Context,
-    project_name: str = typer.Option(None, "--name", "-n", help="Project name"),
-    with_gitnexus: bool = typer.Option(False, "--gitnexus", help="Initialize GitNexus structural awareness"),
-    with_graphify: bool = typer.Option(False, "--graphify", help="Initialize Graphify knowledge graph engine"),
-):
-    """
+    ctx: typer.Context,
+    project_name: str = typer.Option(None, "--name", "-n", help="Project name"),
+    provider: str = typer.Option("openrouter", "--provider", help="Model provider for generated config."),
+    model: str | None = typer.Option(None, "--model", "-m", help="Model id to use for every default role."),
+    role_model: list[str] | None = typer.Option(
+        None,
+        "--role-model",
+        help="Per-role model override in ROLE=MODEL form. Can be repeated.",
+    ),
+    with_gitnexus: bool = typer.Option(False, "--gitnexus", help="Initialize GitNexus structural awareness"),
+    with_graphify: bool = typer.Option(False, "--graphify", help="Initialize Graphify knowledge graph engine"),
+    skip_map: bool = typer.Option(False, "--skip-map", help="Skip generating repo_map.json and agent guides on init."),
+    skip_skills: bool = typer.Option(False, "--skip-skills", help="Skip scaffolding engineering skills into .claude/skills/ on init."),
+):
+    """
     Initialize DevCouncil in the current directory.
     """
     if ctx.invoked_subcommand is not None:
@@ -134,9 +269,21 @@ def init(
         console.print("Use --gitnexus or --graphify to add upgrade paths.")
         raise typer.Exit()
 
+    try:
+        role_models = parse_role_model_overrides(role_model)
+        model_provider = validate_model_provider(provider)
+    except ValueError as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit(code=2) from e
+
     initialize_project(
         Path("."),
         project_name=project_name,
+        model_provider=model_provider,
+        model=model,
+        role_models=role_models,
         with_gitnexus=with_gitnexus,
         with_graphify=with_graphify,
+        with_map=not skip_map,
+        with_skills=not skip_skills,
     )