devcouncil 0.1.1 → 0.2.0

package/README.md

@@ -1,5 +1,9 @@
 # DevCouncil: The Gated AI Orchestrator
 
+<p align="center">
+  <img src="https://raw.githubusercontent.com/bharathvbcr/DevCouncil/main/src/devcouncil/assets/devcouncil_logo_premium.png" alt="DevCouncil Logo" width="300">
+</p>
+
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
 [![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
 [![uv](https://img.shields.io/badge/managed%20by-uv-purple.svg)](https://github.com/astral-sh/uv)
@@ -8,16 +12,19 @@
 
 DevCouncil is a high-integrity command-line orchestration platform for AI-assisted software development. It turns AI implementation from a black-box generation task into a gated engineering workflow where every change is authorized, verified, and traceable back to a requirement.
 
-DevCouncil does not replace coding agents. It sits beside tools like Codex CLI, Gemini CLI, Claude Code, Cursor, and Aider, then owns the plan, task scope, verification loop, repair prompts, and evidence trail.
+DevCouncil does not replace coding agents. It sits beside tools like Codex CLI, Gemini CLI, Claude Code, OpenCode, Google Antigravity CLI, Warp/Oz, Cursor, Aider, and bring-your-own prompt-taking CLIs, then owns the plan, task scope, verification loop, repair prompts, and evidence trail.
 
 ## Documentation
 
 - [Quickstart](docs/quickstart.md): shortest install-to-first-task path.
 - [Daily workflow](docs/workflow.md): manual sidecar loop, verification, repair, and rollback.
-- [Coding CLI integration](docs/coding-cli-integration.md): Codex, Gemini, Claude Code, Cursor, Aider, MCP, hooks, and automated executors.
+- [Coding CLI integration](docs/coding-cli-integration.md): Codex, Gemini, Claude Code, OpenCode, Antigravity, Cursor, Aider, MCP, hooks, and automated executors.
+- [Integration tiers](docs/integration-tiers.md): headless executor vs MCP-only vs sidecar definitions.
 - [CLI command reference](docs/cli-reference.md): available `dev` commands.
 - [Architecture](docs/architecture.md): components, artifact graph, state machine, and gated execution.
+- [Executor adapters](docs/executor-adapters.md): manual, coding CLI, native-preview, Mini-SWE, and OpenHands execution paths.
 - [Live review](docs/live-review.md): `dev watch` session review, cards, signals, and blocking behavior.
+- [Model routing](docs/model-routing.md): provider selection, role models, OpenRouter, Vertex AI, Doubleword, and Ollama (local) setup.
 - [Security model](docs/security.md): redaction, permissions, allowlists, and local state.
 - [Project status](docs/project-status.md): current maturity by subsystem.
 - [Roadmap](docs/roadmap.md): planned work.
@@ -73,12 +80,27 @@ dev verify TASK-001
 
 On a fresh interactive setup, DevCouncil can configure supported coding CLI integrations immediately; pass `--skip-integrations` if you want to defer that step.
 
-Paste only the output from `dev prompt TASK-001` into Codex, Gemini, Claude Code, Cursor, Aider, or another coding tool. Keep `dev setup`, `dev plan`, `dev run`, and `dev verify` in the terminal at the repository root.
+### Run locally on macOS (Apple Silicon + Ollama)
+
+DevCouncil runs fully offline against [Ollama](https://ollama.com) — no API key, no per-token cost. It is Apple-Silicon-aware: `dev setup --provider ollama` sizes the default local model to your Mac's unified memory, and `dev doctor` reports the chip/RAM, pings the Ollama server, and flags a too-small context window.
+
+```bash
+brew install ollama && ollama serve
+ollama pull qwen2.5-coder:32b     # use the size `dev doctor` recommends for your RAM
+export OLLAMA_NUM_CTX=16384       # large planning prompts need a raised context window
+dev setup --provider ollama      # auto-selects the model for your RAM
+```
+
+See [Model routing → macOS / Apple Silicon](docs/model-routing.md) for the RAM-to-model table.
+
+Paste only the output from `dev prompt TASK-001` into Codex, Gemini, Claude Code, OpenCode, Antigravity, Warp, Cursor, Aider, or another coding tool. Keep `dev setup`, `dev plan`, `dev run`, and `dev verify` in the terminal at the repository root.
 
 For an automated end-to-end run with a supported coding CLI installed:
 
 ```bash
 dev e2e "Describe the implementation goal" --executor codex
+dev e2e "Describe the implementation goal" --executor antigravity
+dev e2e "Describe the implementation goal" --executor warp
 dev go "Describe the implementation goal" --executor codex
 ```
 
@@ -87,14 +109,132 @@ dev go "Describe the implementation goal" --executor codex
 For machine-readable agent handoff, write the final report to a stable file:
 
 ```bash
-dev e2e "Describe the implementation goal" --agent
-dev e2e "Describe the implementation goal" --json --report-file .devcouncil/reports/latest.json
+dev e2e "Describe the implementation goal" --executor codex --agent
+dev e2e "Describe the implementation goal" --executor codex --json --report-file .devcouncil/reports/latest.json
 ```
 
-`--agent` is the lowest-friction integration preset. It enables JSON output and writes `.devcouncil/reports/latest.json`.
+`--agent` enables JSON output and writes `.devcouncil/reports/latest.json`. Fresh projects default to manual sidecar mode, so pass an automated executor or set `execution.default_executor` before using `dev e2e` without `--executor`.
 
 See the full [quickstart](docs/quickstart.md) for installation variants, API-key setup, and first-run guidance.
 
+OpenCode and Google Antigravity CLI are built-in executors and MCP integrations:
+
+```bash
+dev integrate opencode --apply
+dev run TASK-001 --executor opencode
+dev agents run TASK-001 --agent opencode --profile default
+dev integrate antigravity --apply
+dev run TASK-001 --executor antigravity
+dev agents run TASK-001 --agent agy --profile default
+```
+
+Register any other local CLI that accepts prompts. `dev agents` is the first-class agent hub; `dev integrate cli-agent` remains available for older scripts:
+
+```bash
+dev agents add myagent --command myagent --arg run --input-mode prompt-file --prompt-arg=--prompt-file --supports-mcp
+dev agents
+dev agents doctor
+dev agents run TASK-001 --agent myagent --profile default
+```
+
+GEPA prompt-profile optimization is available for the agent hub:
+
+```bash
+dev agents optimize --agent codex --profile yolo --evals .devcouncil/evals/agent-profile.jsonl --dry-run
+dev agents optimize --agent codex --profile yolo --evals .devcouncil/evals/agent-profile.jsonl --apply
+```
+
+## Feature Set
+
+DevCouncil is an application layer around coding agents. It does not just emit prompts; it owns the workflow state, validates task scope, records evidence, and produces release-style reports.
+
+### Workflow Features
+
+- **Repository onboarding:** `dev setup` initializes `.devcouncil/`, generates the repo map + `AGENTS.md`/`CLAUDE.md` guides, scaffolds applicable engineering skills, runs environment checks, offers integration setup, and prints the next useful commands. Use `--skip-map` / `--skip-skills` to opt out, or `--scaffold-ci` to also write a starter GitHub Actions workflow.
+- **Repository mapping:** `dev map` writes `.devcouncil/repo_map.json`, identifies important files and subsystems, filters generated/temp files, and keeps managed `AGENTS.md` / `CLAUDE.md` workspace guides synchronized. Subsystems, entry points, neighbors, and important surfaces are now inferred generically for **any** repository — grouped from the directory tree and ranked by an import-graph in-degree — so the map (and the structural context it feeds into prompts) is meaningful outside DevCouncil's own tree, not just within it. The map records the git HEAD and tracked-file fingerprint it was built from; when prompts reuse a map that has fallen behind the current code, they flag it as stale (run `dev map` to refresh) rather than silently feeding wrong structure. The map is also generated automatically on first init.
+- **Engineering skills:** `dev skills` lists the bundled skills and shows which apply to the repository; `dev skills scaffold` writes them into `.claude/skills/<name>/SKILL.md`. A merged always-on `core-engineering` skill (think-before-coding, simplicity, surgical changes, goal-driven execution, evidence-grounded communication) plus domain skills (Android, iOS, Windows, web, AI training) that brief the agent on current SDKs, deprecations, and tooling before coding. Applicable skills are also embedded into `dev prompt` output.
+- **CI scaffolding:** `dev scaffold-ci` writes a starter `.github/workflows/devcouncil.yml` derived from the configured test/lint/typecheck commands, filtered to the detected language stack; it never overwrites existing CI unless `--force`.
+- **Planning council:** `dev plan` turns a goal into requirements, acceptance criteria, assumptions, critique findings, and executable tasks.
+- **Task graph:** `dev tasks` and `dev show TASK-001` expose requirement links, acceptance-criterion links, planned files, expected tests, allowed commands, forbidden changes, dependencies, and status. Tasks can declare `depends_on`; the plan gate rejects unknown dependencies and cycles, and `dev go`/`dev e2e` run tasks in topological order and skip a task whose prerequisites didn't complete (rather than letting it fail spuriously and burn its repair budget).
+- **Scoped task prompts:** `dev prompt TASK-001` creates a constrained implementation prompt for sidecar agents, including file scope, verification expectations, and forbidden changes. The prompt now embeds the current (secret-redacted) contents of each planned file with a top-level symbol outline, structural orientation (from the code-review graph when available, otherwise the generated `repo_map.json`), and a **dependents (blast-radius) list** — the files that import each file being changed, from the map's precomputed reverse-import index — so the agent edits in place and keeps call sites working instead of starting blind. A central prompt budget keeps the core (goal/scope/instructions) always present and fits the optional context sections in priority order (file contents > structural > dependents > skills), dropping the lowest-priority ones with an explicit marker rather than overflowing silently.
+- **Execution:** `dev run TASK-001` supports manual sidecar mode, built-in coding CLI executors, external executors, and registered custom CLI agents.
+- **One-command flow:** `dev e2e "goal"` and `dev go "goal"` can initialize state, plan, run approved tasks, verify the diff, and generate a report. With an automated executor the run is now a **closed loop**: a task that fails verification is re-driven through a bounded self-repair loop (a correction manifest is written and the executor re-run) until it verifies or the `execution.max_repair_attempts` budget is spent, with no-progress detection that stops early when the same blocking gaps reappear.
+- **Verification:** `dev verify TASK-001` captures the diff, runs expected evidence commands, checks planned-file compliance, detects orphan changes, flags unplanned dependency edits, scans for secrets, and links evidence to acceptance criteria. An **empty diff can no longer pass** a task that declares files to create or modify (work that committed earlier is still recognized via the task checkpoint), and the result reports the rigor it ran at (`verification_mode` compiled vs coarse, `diff_empty`, `coverage_measured`/`coverage_skipped_reason`) plus a distinct `advisory_actions` list so an agent never mistakes "passed" for "proven." `dev verify` exits non-zero when a task is blocked so shell-driven agents can gate on `$?`.
+- **Repair:** `dev repair` converts blocking gaps into focused follow-up work instead of leaving failures as vague test output.
+- **Rollback:** `dev rollback TASK-001` uses task checkpoints to revert scoped work when a task needs to be backed out.
+- **Reporting:** `dev report` emits a requirements coverage table, evidence summary, blocking gaps, and live-review blockers; JSON and PR-comment paths are available for automation.
+
+### App Surfaces
+
+- **CLI:** `dev` and `devcouncil` expose the same Typer command surface for local terminal workflows.
+- **Agent hub:** `dev agents` lists built-in and custom agents, `dev agents add` registers prompt-taking CLIs, `dev agents doctor` checks wiring, `dev agents run` executes a task through a named agent/profile, and `dev agents optimize` uses GEPA to tune profile preambles from offline eval examples.
+- **Integration hub:** `dev integrate all --apply` configures supported coding CLI and MCP integrations; targeted setup exists for Codex, Gemini, Claude Code, OpenCode, Antigravity, Cursor, Warp/Oz, hooks, and custom CLI agents. `dev integrate check` now reports each client's **enforcement posture** — `pre-action` (a native hook blocks unauthorized writes before they happen) vs `verify-only` (forbidden changes are caught only after the fact by verification) — so the containment guarantee isn't overstated for clients without a pre-action gate.
+- **MCP server:** `dev mcp-server` exposes DevCouncil context and workflow tools over stdio for MCP-capable clients. `devcouncil_verify_task` now runs DevCouncil's strong compiled per-criterion checks when a provider key is configured (falling back to a clearly-labeled `coarse` mode otherwise), refuses to pass on an empty diff, and returns `verification_mode`, `diff_empty`, `coverage_measured`/`coverage_skipped_reason`, and an `advisory_actions` array alongside the blocking `next_actions`. Cheap, re-verify-free read tools — `devcouncil_get_gaps` and `devcouncil_get_next_actions` — let a reconnecting agent resume outstanding work from persisted gaps (which now carry `file`/`line`/`suggested_command`/`acceptance_criterion_id`). Task leases expire on a config-driven TTL so a crashed agent's task frees itself, with `devcouncil_renew_lease` and `devcouncil_list_leases` for long runs and fleet supervision; a partial-unique DB index enforces a single active lease per task, so concurrent checkouts can't both win the writer slot. A pure-MCP agent can now make the change itself through lease-gated write tools — `devcouncil_write_file` and `devcouncil_apply_patch` — which policy-check every target path *before* it lands (out-of-scope, protected, or escaping paths are rejected; a patch with any out-of-scope target is rejected whole, never partially applied), write atomically, and record a `FileChangeEvent` for provenance. The corpus is also browsable as MCP **resources** (`devcouncil://report`, `devcouncil://tasks`, `devcouncil://gaps`, `devcouncil://cards`, `devcouncil://task/{id}`) so a host can read project state without a tool call. `devcouncil_get_task_provenance` then exposes that audit trail — gated file changes, verification runs, diff-coverage evidence, and the latest correction manifest — so what happened on disk is inspectable. The diff↔coverage proof is now also retained across graph reloads (it was previously dropped), so reports and `dev status` reflect whether the changed lines were actually exercised.
+- **Live review:** `dev watch` tracks review cards, signals, blocking feedback, and repair guidance while a session is active.
+- **Trace viewer:** `dev trace tail --follow` streams local DevCouncil trace events for execution, verification, and agent handoff.
+- **Dashboard:** `dev dashboard --open` serves a local status dashboard and opens it in the default browser for project state and live workflow visibility.
+- **Agent-consumable CLI:** machine output for shell-driven agents — `dev prompt --json` (`{ok, task_id, prompt}`), `dev handoff --json` (`{ok, manifest_path, run_id, next_command}` to chain `dev run`), `dev verify` exits non-zero when blocked, and `dev status`/`dev report` accept `--fail-on-blocking` to exit non-zero on outstanding blocking gaps so a loop can gate on `$?`.
+- **Config editor:** `dev config` and `dev config models` inspect/update provider, model, executor, and command configuration.
+- **Artifact tools:** `dev artifacts validate` checks stored graph integrity.
+- **Code intelligence:** `dev lsp inspect` checks optional language-server readiness, and `dev ast match` searches code structurally.
+- **Doctor:** `dev doctor` validates local dependencies, commands, and environment prerequisites before a workflow fails deeper in execution.
+
+### Agent And Executor Support
+
+DevCouncil works with human-in-the-loop sidecar sessions and automated prompt handoff:
+
+- **Manual sidecar:** paste `dev prompt TASK-001` into any agent, then run `dev verify TASK-001`.
+- **Built-in coding CLI adapters:** `codex`, `gemini`, `claude`, `opencode`, `antigravity`, `warp`, `cursor`, `aider`, and aliases such as `codex-cli`, `gemini-cli`, `claude-code`, `opencode-cli`, `antigravity-cli`, `agy`, `agy-cli`, `warp-cli`, `oz`, `cursor-agent`, and `cursor-cli`.
+- **Custom CLI agents:** register any prompt-taking command with stdin, argument, or prompt-file handoff.
+- **Execution profiles:** custom agents can use profiles such as `default`, `yolo`, and `prod` to adjust prompt constraints while DevCouncil still verifies the final diff.
+- **External automated adapters:** `mini`, `openhands`, `native-preview`, and `native` are available when the corresponding local executor is configured.
+- **Hook-aware clients:** `dev integrate hooks --apply` installs write/shell hooks for Codex, Gemini, Claude, Cursor, and OpenCode so DevCouncil policy can block unauthorized actions before verification. The post-task hook can run deterministic verification of the active task and record gaps (enable `execution.verify_on_post_task`; off by default to keep hooks fast). File-write policy uses one shared path normalizer across the hook and task-policy paths that resolves every target and **denies anything outside the project root** (so the path that's checked is the path that's enforced), and the pre-tool-use hook is fail-closed: an unparseable or error payload is surfaced (and blocked under `--strict`/`DEVCOUNCIL_HOOK_STRICT`) rather than silently allowed.
+
+### Gates And Evidence
+
+DevCouncil blocks completion on concrete gaps rather than model confidence:
+
+- **Plan approval gates:** requirements must have acceptance criteria, acceptance criteria need verification methods, tasks must map to known requirements and acceptance criteria, high-impact assumptions must be resolved, and high/critical critique findings must be closed.
+- **Task readiness gates:** the working tree must be clean for the task, planned files must be declared, and each task needs allowed commands plus expected verification evidence.
+- **Diff gates:** verification detects files changed outside the planned task scope, dependency-file edits made without authorization, deleted/added files, and untracked file diffs.
+- **Evidence gates:** passing evidence commands are linked back to acceptance criteria; missing passing evidence becomes a blocking gap.
+- **Security gates:** secret scanning runs over captured diffs, and command output is redacted before it is written to logs.
+- **Live-review gates:** unresolved critical review cards can block task verification and appear in reports.
+
+### Providers, Models, And Cost Tracking
+
+- **Providers:** OpenRouter, Vertex AI, Doubleword, and Ollama (local, no key) are supported through local configuration and secrets.
+- **Role models:** planner, critic, arbiter, reviewer, and repair roles can share one model or use per-role overrides.
+- **Structured repair:** model routing includes JSON repair paths for structured planning and review outputs.
+- **Model defaults:** packaged YAML defaults ship with the tool so installed CLI environments do not depend on source-tree-only files.
+- **Telemetry:** local trace and cost data feed `dev status`, reports, and dashboard surfaces.
+
+### Reports And Automation Outputs
+
+- **Markdown reports:** include verdict, coverage summary, requirement/task mapping, blocking gaps, and live-review status.
+- **JSON reports:** `--json` and `--report-file` support machine-readable handoff to other automation.
+- **Agent preset:** `--agent` writes `.devcouncil/reports/latest.json` for stable downstream consumption.
+- **PR comments:** `dev report --github-pr-comment` and `dev report --gitlab-pr-comment` can publish verification summaries to pull/merge requests.
+- **GitHub checks:** preview GitHub report/check surfaces are available for repository automation.
+
+### Local State And Files
+
+DevCouncil stores local workflow state in the target repository:
+
+- `.devcouncil/config.yaml`: provider, executor, command, integration, and workflow settings.
+- `.devcouncil/secrets.env`: local provider secrets such as API keys or Vertex AI project/location values. Git-ignored; copy `.devcouncil/secrets.env.example` and fill in real values. Environment variables take precedence over this file.
+- `.devcouncil/repo_map.json`: generated repository map and subsystem navigation index.
+- `.devcouncil/state.sqlite`: SQLite state for requirements, assumptions, tasks, evidence, gaps, critique findings, and project phase history.
+- `.devcouncil/checkpoints/`: task snapshots used by verification and rollback.
+- `.devcouncil/logs/`: redacted stdout/stderr from verification commands.
+- `.devcouncil/runs/<run-id>/agent-run.json`: prompt, executor, profile, exit status, and run metadata for automated agent executions.
+- `.devcouncil/reports/latest.json`: optional machine-readable report generated by `dev e2e --agent`.
+- `.devcouncil/integrations/` and `.agents/`: generated integration files such as Warp/Oz MCP JSON and Antigravity MCP config.
+
+### Maturity
+
+The stable daily workflow is planning, manual sidecar execution, verification, repair, rollback, and reporting. Coding CLI executors, MCP, live review, dashboard, PR comments, LSP/AST tools, and GitHub check surfaces are preview features. Native autonomous execution is experimental and still requires DevCouncil verification before work is considered complete.
+
 ## Core Flow
 
 DevCouncil's recommended default is **Manual Sidecar Mode**:
@@ -108,6 +248,50 @@ DevCouncil's recommended default is **Manual Sidecar Mode**:
 
 The detailed task-by-task workflow lives in [docs/workflow.md](docs/workflow.md).
 
+## How The Repo Runs
+
+```mermaid
+flowchart TD
+    user["User runs dev/devcouncil"] --> cli["Typer CLI\nsrc/devcouncil/cli/main.py"]
+    cli --> config["Config + secrets\n.devcouncil/config.yaml\n.devcouncil/secrets.env"]
+    cli --> map["Repo map\nsrc/devcouncil/indexing/repo_mapper.py"]
+    cli --> planning["Planning commands\ndev plan / dev prompt / dev tasks"]
+
+    config --> providers["Model providers\nOpenRouter, Vertex AI, Doubleword, or Ollama"]
+    providers --> router["ModelRouter\nrole models, cache, telemetry, structured JSON repair"]
+    router --> planning
+
+    planning --> storage["SQLite + repositories\nrequirements, tasks, gaps, evidence, state"]
+    storage --> artifactGraph["Artifact graph\nRequirement -> Task -> Diff -> Evidence"]
+    artifactGraph --> gates["Gate policy\nplanned files, commands, secret checks"]
+
+    gates --> manual["Manual sidecar\ndev prompt + user agent edits"]
+    gates --> coding["Coding CLI executor\nCodex, Gemini, Claude, OpenCode, Antigravity, Warp, custom CLIs"]
+    gates --> native["Native preview executor\nLLM router + TaskRunner"]
+    gates --> external["Mini-SWE / OpenHands adapters"]
+
+    coding --> runlog["Run artifacts\nprompt file, redacted logs, manifest, trace events"]
+    native --> runlog
+    external --> runlog
+    manual --> diff["Repository diff"]
+    runlog --> diff
+
+    diff --> verify["Verifier\ndev verify / automatic post-run verification"]
+    verify --> evidence["Evidence + gaps"]
+    evidence --> storage
+    evidence --> repair["Repair loop\ndev repair / dev watch repair"]
+    evidence --> report["Reports\ndev report, JSON, GitHub/GitLab comments"]
+
+    cli --> mcp["MCP server\ndev mcp-server"]
+    mcp --> storage
+    mcp --> artifactGraph
+    mcp --> repair
+
+    cli --> live["Live review\ndev watch"]
+    live --> cards["Cards + signals\nblocking review feedback"]
+    cards --> report
+```
+
 ## Install From Source
 
 For local development inside this checkout:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devcouncil",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Gated orchestrator for AI-assisted software development",
   "license": "Apache-2.0",
   "homepage": "https://github.com/bharathvbcr/DevCouncil#readme",
@@ -27,6 +27,10 @@
     "bin/",
     "src/**/*.py",
     "src/**/*.md",
+    "src/**/*.png",
+    "src/**/*.svg",
+    "src/**/*.yaml",
+    "src/**/*.mjs",
     "pyproject.toml",
     "uv.lock",
     "README.md",
@@ -37,9 +41,12 @@
     "install:editable": "uv pip install -e .",
     "dev": "uv run devcouncil",
     "pack:check": "npm pack --dry-run",
+    "smoke:wheel": "uv run python scripts/check-wheel-assets.py",
+    "smoke:package": "node scripts/npm-runtime-smoke.mjs",
     "test": "uv run pytest",
     "lint": "uv run ruff check .",
-    "check": "uv run ruff check . && uv run pytest"
+    "typecheck": "uv run mypy src",
+    "check": "uv run ruff check . && uv run mypy src && uv run pytest"
   },
   "engines": {
     "node": ">=18"

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devcouncil"
-version = "0.1.1"
+version = "0.2.0"
 description = "Gated orchestrator for AI-assisted software development"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -11,10 +11,17 @@ dependencies = [
     "pyyaml>=6.0.1",
     "sqlmodel>=0.0.19",
     "httpx>=0.27.0",
-    "gitpython>=3.1.43",
+    "gitpython>=3.1.49",
     "mcp>=1.27.0",
+    "gepa>=0.1.1",
+    "watchdog>=4.0.0",
 ]
 
+[project.urls]
+Homepage = "https://github.com/bharathvbcr/DevCouncil"
+Repository = "https://github.com/bharathvbcr/DevCouncil.git"
+Issues = "https://github.com/bharathvbcr/DevCouncil/issues"
+
 [project.scripts]
 dev = "devcouncil.cli.main:app"
 devcouncil = "devcouncil.cli.main:app"
@@ -24,6 +31,24 @@ dev = [
     "pytest>=8.2.0",
     "ruff>=0.4.4",
     "mypy>=1.10.0",
+    "types-pyyaml>=6.0.12.20260408",
+    # Used only to exercise the diff↔coverage path end-to-end in tests. DevCouncil
+    # never requires coverage at runtime — it uses whatever the target repo provides.
+    "coverage>=7.4",
+]
+
+[tool.uv]
+# Security floors for transitive dependencies (Dependabot advisories, 2026-06).
+# These are not direct deps; constraint-dependencies pins their minimum patched
+# version in the resolver without adding them to the dependency tree, so they can
+# never resolve back below the fix.
+constraint-dependencies = [
+    "cryptography>=48.0.1",
+    "starlette>=1.3.1",
+    "pyjwt>=2.13.0",
+    "python-multipart>=0.0.31",
+    "pydantic-settings>=2.14.2",
+    "idna>=3.15",
 ]
 
 [tool.pytest.ini_options]
@@ -32,3 +57,10 @@ testpaths = ["tests"]
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel.force-include]
+"src/devcouncil/llm/model_defaults.yaml" = "devcouncil/llm/model_defaults.yaml"
+"src/devcouncil/telemetry/model_pricing.yaml" = "devcouncil/telemetry/model_pricing.yaml"
+"src/devcouncil/assets/devcouncil-logo.svg" = "devcouncil/assets/devcouncil-logo.svg"
+"src/devcouncil/assets/devcouncil_logo_premium.png" = "devcouncil/assets/devcouncil_logo_premium.png"
+"src/devcouncil/integrations/opencode_devcouncil_plugin.mjs" = "devcouncil/integrations/opencode_devcouncil_plugin.mjs"

package/src/devcouncil/app/config.py

@@ -6,6 +6,8 @@ Replaces scattered yaml.safe_load() calls with a single validated config service
 from __future__ import annotations
 
 import os
+import shutil
+import subprocess
 from pathlib import Path
 from typing import Dict, List
 
@@ -34,6 +36,34 @@ class CommandsConfig(BaseModel):
     typecheck: List[str] = Field(default_factory=list)
 
 
+class VerificationSandboxConfig(BaseModel):
+    docker_image: str = "python:3.12-slim"
+    docker_setup_commands: List[str] = Field(default_factory=list)
+    nix_flake_attr: str | None = None
+
+
+class DiffCoverageConfig(BaseModel):
+    """Diff↔coverage gating: prove the *changed* lines were exercised by tests.
+
+    ``measure`` runs the diff-coverage analysis and records it as evidence (and a
+    non-blocking signal) whenever the target repo's coverage tooling is present.
+    ``enforce`` promotes an unexercised diff to a *blocking* gap. Enforcement is
+    off by default so the signal is visible before it ever gates — a passing test
+    that does not touch the new code is surfaced first, then teams opt in to
+    blocking. ``min_ratio`` of 0.0 means "require at least one changed executable
+    line to be exercised"; a higher value demands that fraction of changed lines.
+    """
+
+    measure: bool = True
+    enforce: bool = False
+    min_ratio: float = 0.0
+
+
+class VerificationConfig(BaseModel):
+    sandbox: VerificationSandboxConfig = Field(default_factory=VerificationSandboxConfig)
+    diff_coverage: DiffCoverageConfig = Field(default_factory=DiffCoverageConfig)
+
+
 class GatesConfig(BaseModel):
     require_clean_git_before_task: bool = True
     block_orphan_diffs: bool = True
@@ -48,6 +78,16 @@ class ExecutionConfig(BaseModel):
     max_repair_attempts: int = 3
     checkpoint_before_each_task: bool = True
     command_timeout: int = 300
+    stream_cli_output: bool = False
+    # Default lifetime of an MCP task lease. A crashed/disconnected agent's lease
+    # auto-expires after this, so the task frees up without a human running force.
+    lease_ttl_seconds: int = 1800
+    # When true, the post-task coding-CLI hook runs deterministic verification of the
+    # active task (and records gaps) instead of only printing a reminder. Off by default
+    # so hooks stay fast/cheap unless a team opts in.
+    verify_on_post_task: bool = False
+    cursor_resume_mode: str = "off"
+    coding_cli_probe_order: List[str] = Field(default_factory=list)
 
 
 class PrivacyConfig(BaseModel):
@@ -75,10 +115,89 @@ class LiveReviewIntegrationConfig(BaseModel):
     default_client: str = "claude"
 
 
+class WarpIntegrationConfig(BaseModel):
+    enabled: bool = False
+    command: str = "oz"
+    run_mode: str = "local"
+    mcp_config_path: str = ".devcouncil/integrations/warp-mcp.json"
+    profile: str | None = None
+    model: str | None = None
+    environment: str | None = None
+    share: List[str] = Field(default_factory=list)
+
+
+class OpenCodeIntegrationConfig(BaseModel):
+    enabled: bool = False
+    config_path: str = "opencode.json"
+
+
+class AntigravityIntegrationConfig(BaseModel):
+    enabled: bool = False
+    mcp_config_path: str = ".agents/mcp_config.json"
+
+
+class CursorIntegrationConfig(BaseModel):
+    enabled: bool = False
+    config_path: str = ".cursor/mcp.json"
+    hooks_path: str = ".cursor/hooks.json"
+
+
+class AiderIntegrationConfig(BaseModel):
+    enabled: bool = False
+
+
+class CliAgentProfileConfig(BaseModel):
+    description: str = ""
+    timeout_seconds: int | None = None
+    prompt_preamble: str = ""
+    require_explicit_confirmation: bool = False
+    # Per-profile CLI containment overrides. Empty/None reproduce today's behavior
+    # exactly so a profile that only sets a prompt preamble is a no-op on the
+    # subprocess invocation. ``extra_args`` are appended verbatim to the resolved
+    # command, ``permission_mode`` is translated into the right per-CLI flag where
+    # known (and overly-permissive flags are dropped for stricter modes), and
+    # ``model`` overrides the model flag for CLIs that accept one.
+    extra_args: List[str] = Field(default_factory=list)
+    permission_mode: str | None = None
+    model: str | None = None
+
+
+class CustomCliAgentConfig(BaseModel):
+    command: str
+    args: List[str] = Field(default_factory=list)
+    input_mode: str = "stdin"
+    prompt_arg: str | None = None
+    timeout_seconds: int | None = None
+    env: Dict[str, str] = Field(default_factory=dict)
+    display_name: str | None = None
+    kind: str = "custom"
+    supports_mcp: bool = False
+    supports_diff_review: bool = False
+    default_profile: str = "default"
+    help_command: List[str] = Field(default_factory=list)
+
+
+class CliAgentsIntegrationConfig(BaseModel):
+    enabled: bool = True
+    profiles: Dict[str, CliAgentProfileConfig] = Field(default_factory=dict)
+    agents: Dict[str, CustomCliAgentConfig] = Field(default_factory=dict)
+
+
+class McpIntegrationConfig(BaseModel):
+    write_task_scope_to_config: bool = False
+
+
 class IntegrationsConfig(BaseModel):
+    mcp: McpIntegrationConfig = Field(default_factory=McpIntegrationConfig)
     agent_flow: AgentFlowIntegrationConfig = Field(default_factory=AgentFlowIntegrationConfig)
     code_review_graph: CodeReviewGraphIntegrationConfig = Field(default_factory=CodeReviewGraphIntegrationConfig)
     live_review: LiveReviewIntegrationConfig = Field(default_factory=LiveReviewIntegrationConfig)
+    cursor: CursorIntegrationConfig = Field(default_factory=CursorIntegrationConfig)
+    aider: AiderIntegrationConfig = Field(default_factory=AiderIntegrationConfig)
+    antigravity: AntigravityIntegrationConfig = Field(default_factory=AntigravityIntegrationConfig)
+    warp: WarpIntegrationConfig = Field(default_factory=WarpIntegrationConfig)
+    opencode: OpenCodeIntegrationConfig = Field(default_factory=OpenCodeIntegrationConfig)
+    cli_agents: CliAgentsIntegrationConfig = Field(default_factory=CliAgentsIntegrationConfig)
 
 
 class ProviderConfig(BaseModel):
@@ -97,6 +216,7 @@ class DevCouncilConfig(BaseModel):
     commands: CommandsConfig = Field(default_factory=CommandsConfig)
     gates: GatesConfig = Field(default_factory=GatesConfig)
     execution: ExecutionConfig = Field(default_factory=ExecutionConfig)
+    verification: VerificationConfig = Field(default_factory=VerificationConfig)
     privacy: PrivacyConfig = Field(default_factory=PrivacyConfig)
     integrations: IntegrationsConfig = Field(default_factory=IntegrationsConfig)
 
@@ -107,25 +227,38 @@ def load_config(project_root: Path = Path(".")) -> DevCouncilConfig:
     Returns DevCouncilConfig with defaults for any missing fields.
     Raises FileNotFoundError if config doesn't exist.
     """
-    import yaml
+    import yaml  # type: ignore[import-untyped]
 
     config_path = project_root / ".devcouncil" / "config.yaml"
     if not config_path.exists():
         raise FileNotFoundError(f"Config not found at {config_path}. Run 'dev init' first.")
 
-    with open(config_path) as f:
-        raw = yaml.safe_load(f) or {}
+    with open(config_path, encoding="utf-8") as f:
+        try:
+            raw = yaml.safe_load(f) or {}
+        except yaml.YAMLError as exc:
+            raise ValueError(
+                f"Invalid YAML in {config_path}: {exc}. Fix the syntax or re-run 'dev init'."
+            ) from exc
 
     return DevCouncilConfig.model_validate(raw)
 
 
 def provider_api_key_env_var(provider: str = "openrouter") -> str:
+    normalized = provider.strip().lower().replace("-", "").replace("_", "")
     env_map = {
         "openrouter": "OPENROUTER_API_KEY",
+        "vertexai": "VERTEXAI_ACCESS_TOKEN",
+        "doubleword": "DOUBLEWORD_API_KEY",
+        "ollama": "OLLAMA_API_KEY",
         "openai": "OPENAI_API_KEY",
         "anthropic": "ANTHROPIC_API_KEY",
     }
-    return env_map.get(provider, f"{provider.upper()}_API_KEY")
+    return env_map.get(normalized, f"{normalized.upper()}_API_KEY")
+
+
+def _normalized_provider_name(provider: str) -> str:
+    return provider.strip().lower().replace("-", "").replace("_", "")
 
 
 def load_local_secrets(project_root: Path = Path(".")) -> Dict[str, str]:
@@ -143,6 +276,24 @@ def load_local_secrets(project_root: Path = Path(".")) -> Dict[str, str]:
     return secrets
 
 
+def get_gcloud_access_token() -> str | None:
+    executable = shutil.which("gcloud")
+    if not executable:
+        return None
+    try:
+        token = subprocess.check_output(
+            [executable, "auth", "print-access-token"],
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=10,
+        ).strip()
+    except Exception:
+        return None
+    return token or None
+
+
 def get_api_key(provider: str = "openrouter", project_root: Path = Path(".")) -> str:
     """Retrieve the API key for the configured provider from environment.
     
@@ -150,9 +301,20 @@ def get_api_key(provider: str = "openrouter", project_root: Path = Path(".")) ->
     """
     env_var = provider_api_key_env_var(provider)
     key = os.environ.get(env_var) or load_local_secrets(project_root).get(env_var)
+    if not key and _normalized_provider_name(provider) == "vertexai":
+        key = get_gcloud_access_token()
+    if not key and _normalized_provider_name(provider) == "ollama":
+        # Ollama is a local server and needs no API key; an explicitly-set
+        # OLLAMA_API_KEY still flows through above if present.
+        return ""
     if not key:
+        extra = (
+            " You can also authenticate with 'gcloud auth login' for vertexai."
+            if _normalized_provider_name(provider) == "vertexai"
+            else ""
+        )
         raise ValueError(
             f"API key not found. Set {env_var} in your environment or run 'dev setup'. "
-            f"Provider: {provider}"
+            f"Provider: {provider}.{extra}"
         )
     return key

package/src/devcouncil/artifacts/graph.py

@@ -18,7 +18,7 @@ from typing import Any, Dict, List, Set, Tuple
 from devcouncil.domain.requirement import Requirement, AcceptanceCriterion
 from devcouncil.domain.task import Task
 from devcouncil.domain.assumption import Assumption
-from devcouncil.domain.evidence import CommandResult, DiffEvidence, TestEvidence
+from devcouncil.domain.evidence import CommandResult, DiffCoverageEvidence, DiffEvidence, TestEvidence
 from devcouncil.domain.gap import Gap
 from devcouncil.domain.critique import CritiqueFinding
 
@@ -35,6 +35,7 @@ class ArtifactGraph:
     test_evidence: List[TestEvidence] = field(default_factory=list)
     diff_evidence: List[DiffEvidence] = field(default_factory=list)
     command_results: List[CommandResult] = field(default_factory=list)
+    diff_coverage_evidence: List[DiffCoverageEvidence] = field(default_factory=list)
 
     # --- Mutation ---
 
@@ -62,6 +63,17 @@ class ArtifactGraph:
     def add_command_result(self, cr: CommandResult) -> None:
         self.command_results.append(cr)
 
+    def add_diff_coverage_evidence(self, ev: DiffCoverageEvidence) -> None:
+        self.diff_coverage_evidence.append(ev)
+
+    def diff_coverage_findings(self) -> List[DiffCoverageEvidence]:
+        """Measured diff-coverage runs where the changed lines were NOT fully exercised
+        — i.e. a green suite that did not actually run the new code."""
+        return [
+            ev for ev in self.diff_coverage_evidence
+            if ev.measured and ev.changed_lines and ev.covered_lines < ev.changed_lines
+        ]
+
     # --- Coverage Queries ---
 
     def requirements_without_tasks(self) -> List[Requirement]:
@@ -80,10 +92,16 @@ class ArtifactGraph:
         return [r for r in self.requirements.values() if not r.acceptance_criteria]
 
     def acceptance_criteria_without_evidence(self) -> List[Tuple[str, AcceptanceCriterion]]:
-        """AC IDs that have no test evidence mapped to them."""
+        """AC IDs that have no *passing* test evidence mapped to them.
+
+        Only ``passed`` evidence counts: a failed or not-run check is not proof, so
+        it must not remove a criterion from the unproven list (which would feed a
+        falsely-green coverage summary to ``dev status`` and the MCP surface).
+        """
         evidenced_ac_ids: Set[str] = set()
         for ev in self.test_evidence:
-            evidenced_ac_ids.add(ev.acceptance_criterion_id)
+            if getattr(ev, "status", "passed") == "passed":
+                evidenced_ac_ids.add(ev.acceptance_criterion_id)
 
         results: List[Tuple[str, AcceptanceCriterion]] = []
         for req in self.requirements.values():
@@ -137,6 +155,8 @@ class ArtifactGraph:
             "ac_without_evidence": len(self.acceptance_criteria_without_evidence()),
             "total_gaps": len(self.gaps),
             "blocking_gaps": len(self.blocking_gaps()),
+            "diff_coverage_runs": len(self.diff_coverage_evidence),
+            "unexercised_diff_findings": len(self.diff_coverage_findings()),
             "open_findings": len(self.open_findings()),
             "high_critical_open_findings": len(self.open_findings("high")),
             "unconfirmed_high_assumptions": len(self.unconfirmed_high_impact_assumptions()),