devcouncil 0.1.1 → 0.2.1

package/README.md

@@ -1,162 +1,284 @@
-# DevCouncil: The Gated AI Orchestrator
+# DevCouncil: Components and Modules for AI Development
 
+[![Website](https://img.shields.io/badge/website-devcouncil.vbcr.dev-10B981?style=flat&logo=safari&logoColor=white)](https://devcouncil.vbcr.dev/)
+[![CI](https://github.com/bharathvbcr/DevCouncil/actions/workflows/ci.yml/badge.svg)](https://github.com/bharathvbcr/DevCouncil/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/devcouncil)](https://www.npmjs.com/package/devcouncil)
 [![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)
 
-**"DevCouncil should not merely generate code. It should make AI-generated work prove that it satisfied the original intent."**
+<p align="center">
+  <a href="https://devcouncil.vbcr.dev/"><strong>Explore the Interactive Architecture &amp; Code Graph Showcase (devcouncil.vbcr.dev) &rarr;</strong></a>
+</p>
 
-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 should not merely generate code. It should make AI-generated work prove that it satisfied the original intent."**  
+> *Evidence, not model confidence, is the final authority.*
 
-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 is **components and modules** for AI-assisted software development. It ships independently installable binaries and libraries — code intelligence (`devmap`), task and lease state (`dcstore`), deterministic verification (`dcverify`), ignore-aware search (`dcgrep`), and a Go host (`devcouncil` / `dev`) — so a harness or an app can take only the pieces it needs and update them one at a time.
 
-## Documentation
+See [repository input and verification boundaries](docs/SECURITY_BOUNDARIES.md)
+for executable selection, filesystem protections, resource limits, and the
+difference between unavailable evidence and a passing check.
+
+**Manvi wraps these components** into a coding-agent harness (turn loop, providers, policy, TUI, `manvi serve`). **GitPulse** uses Manvi for policy, workbench, and agent hosting, and DevCouncil components for code intelligence and related analysis. DevCouncil does not replace coding agents; it sits beside Claude Code, Codex, Cursor, and others as selectable modules.
+
+---
+
+## Architecture & Components
+
+DevCouncil's core runtime is a set of standalone, compiled native modules. Each binary is useful on its own, sits on `PATH`, and can be spawned or linked by a host that wants that one job:
+
+| Binary | Language | Role & Ownership |
+|--------|----------|------------------|
+| `devcouncil` / `dev` | **Go** | Host orchestrator: Stdio MCP server (`mcp`), multi-host agent integration (`integrate`), engineering skills distribution (`skills`), task verification (`verify`), and devmap forwarding (`map`, `graph`, `ast`). |
+| `devmap` | **Rust** | Code intelligence engine: 36+ tree-sitter language extractors, symbol resolution, blast-radius calculation, dead-code analysis, workspace guides (`AGENTS.md`), and DevMap MCP server (`devmap mcp`). |
+| `dcstore` | **Rust** | State & lease store: SQLite-backed task repository, mutual-exclusion leases for concurrent agent building, evidence records, and gap tracking. |
+| `dcverify` | **Rust** | Deterministic verification: Unified-diff parsing, planned file scope classification, anti-laziness/stub gates, test coverage evaluation, and typed `next_actions` repair signals. |
+| `dcgrep` | **Rust** | Code search: Ripgrep-powered ignore-aware search engine with optional trigram indexing (`tgrep-core`). |
+
+### How hosts consume the modules
+
+- **Manvi** wraps the components: it drives the agent loop, provider routing, policy ladder, and TUI, and reaches each binary over JSON on stdio. A host that wants a harness embeds Manvi rather than reimplementing it.
+- **GitPulse** uses both for their respective jobs: Manvi (`manvi serve`) for policy, workbench, and agent hosting; selected DevCouncil crates and the `devmap` CLI for in-process code intelligence. It does not have to take every module.
+- **Other apps** pick the same way — `devmap` alone, `dcverify` alone, the Go host MCP, or the full set. Updating one module does not require shipping the rest.
+
+> [!NOTE]
+> DevCouncil is built entirely as native compiled Go and Rust binaries; legacy Python orchestration has been retired (see [docs/PHASE7_LONG_TAIL.md](docs/PHASE7_LONG_TAIL.md)).
+
+---
+
+## Installation
 
-- [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.
-- [CLI command reference](docs/cli-reference.md): available `dev` commands.
-- [Architecture](docs/architecture.md): components, artifact graph, state machine, and gated execution.
-- [Live review](docs/live-review.md): `dev watch` session review, cards, signals, and blocking behavior.
-- [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.
+DevCouncil supports macOS, Linux, and Windows. Requires a Go toolchain (`>=1.22`), Rust/`cargo`, and Git.
 
-## Why DevCouncil Exists
+### 1. Build and Install Native Binaries
 
-Standard AI coding agents are good at producing the happy path, but they often fail in expensive ways when complexity grows:
+From a clone of this repository:
 
-- **Requirement omission:** agents lose track of original product or PRD constraints across chat turns.
-- **Architecture drift:** agents add dependencies or change design patterns without explicit authorization.
-- **Unverified success:** agents claim tests passed without proving that the new logic was exercised.
-- **Hidden assumptions:** important decisions stay buried in transient chat history instead of durable project artifacts.
+```bash
+# macOS & Linux: builds Go host and all Rust analysis binaries into ~/.local/bin
+bash scripts/install.sh
+
+# Standalone DevMap (no Go host)
+bash scripts/install.sh --only=devmap
 
-**DevCouncil makes evidence, not model confidence, the final authority.**
+# Analysis suite only (devmap dcstore dcverify dcgrep)
+bash scripts/install.sh analysis
 
-It creates a persistent **Requirement -> Task -> Diff -> Evidence** graph, blocks completion when evidence is missing, detects unauthorized changes, and produces a final report that can be reviewed like an engineering artifact.
+# Windows (PowerShell):
+.\scripts\install.ps1
+.\scripts\install.ps1 -Components devmap
+```
 
-## Quickstart
+To build and install the analysis components (`devmap`, `dcstore`, `dcverify`, `dcgrep`):
 
-Run DevCouncil commands in a normal terminal from the root of the repository you want DevCouncil to manage. Do not run these commands inside a coding CLI chat.
+```bash
+# Build & install all analysis components to ~/.local/bin
+bash scripts/install-components.sh
 
-Install `uv` first if it is missing:
+# Or install specific components
+bash scripts/install-components.sh devmap
+bash scripts/install-components.sh dcstore dcverify dcgrep
 
-```powershell
-powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+# Build the Go host binary
+go -C backend/go_orchestrator build -o ~/.local/bin/devcouncil ./cmd/devcouncil
+ln -sf devcouncil ~/.local/bin/dev
 ```
 
-On macOS or Linux:
+Ensure `~/.local/bin` is in your `PATH`:
 
 ```bash
-curl -LsSf https://astral.sh/uv/install.sh | sh
+export PATH="$HOME/.local/bin:$PATH"
 ```
 
-Install DevCouncil from npm:
+### 2. Optional Global npm Shim
+
+If you prefer to dispatch through npm, install the lightweight Node.js wrapper (Node 18+). The npm package ships a shim that resolves and executes the native binaries:
 
 ```bash
 npm install -g devcouncil
-devcouncil --help
-dev --help
 ```
 
-Start the first gated workflow from your target repository:
+### 3. Verify Environment
 
 ```bash
-cd path/to/your/project
-dev setup
-dev plan "Describe the implementation goal"
-dev tasks
-dev run TASK-001 --executor manual
-dev prompt TASK-001
-dev verify TASK-001
+devcouncil --help
+dev --help
+devmap --version
+dcverify health
+dcstore --db .devcouncil/state.sqlite health
+dcgrep health
 ```
 
-On a fresh interactive setup, DevCouncil can configure supported coding CLI integrations immediately; pass `--skip-integrations` if you want to defer that step.
+---
+
+## Core Capabilities & Workflows
 
-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.
+### 1. Coding Agent Integration (`devcouncil integrate`)
 
-For an automated end-to-end run with a supported coding CLI installed:
+Connect DevCouncil's MCP server to Cursor or Claude Code. `--write-gate` has been removed: it named a pre-tool-use gate that only the retired lifecycle hooks installed, and nothing enforced it. Use `dev hook status` to inspect old registrations and `dev hook disable --dry-run` to preview cleanup.
 
 ```bash
-dev e2e "Describe the implementation goal" --executor codex
-dev go "Describe the implementation goal" --executor codex
+devcouncil integrate cursor --apply
+devcouncil integrate claude --apply
+
+# Stub receipt only — not a working installer:
+# devcouncil integrate antigravity --apply
+
+# Verify existing integration configuration
+devcouncil integrate cursor --check
 ```
 
-`dev e2e` is the explicit one-command integration target for coding agents. It initializes local DevCouncil state if needed, plans the goal, runs each approved task through the selected executor, verifies the resulting diff, and prints the final report. If `--executor` is omitted, DevCouncil uses `execution.default_executor` from `.devcouncil/config.yaml`. `dev go` is kept as a shorter alias for the same flow.
+### 2. Engineering Skills Delivery (`devcouncil skills`)
 
-For machine-readable agent handoff, write the final report to a stable file:
+Deliver verified engineering practices and code-intelligence skills directly into agent skill folders (`.agents/skills`, `.claude/skills`, `.cursor/skills`):
 
 ```bash
-dev e2e "Describe the implementation goal" --agent
-dev e2e "Describe the implementation goal" --json --report-file .devcouncil/reports/latest.json
-```
+# List available skills embedded in the binary
+devcouncil skills list
 
-`--agent` is the lowest-friction integration preset. It enables JSON output and writes `.devcouncil/reports/latest.json`.
+# Scaffold all applicable skills into the repository
+devcouncil skills scaffold
 
-See the full [quickstart](docs/quickstart.md) for installation variants, API-key setup, and first-run guidance.
+# Scaffold a specific skill (e.g. core-engineering or devmap)
+devcouncil skills scaffold --skill core-engineering
+devcouncil skills scaffold --skill devmap
+```
 
-## Core Flow
+### 3. Repository Mapping & Code Intelligence (`devmap` / `dev map`)
 
-DevCouncil's recommended default is **Manual Sidecar Mode**:
+Build and query deep semantic relationships across your codebase without an LLM:
 
-1. DevCouncil plans the work and creates a task graph.
-2. You ask DevCouncil for one constrained task prompt.
-3. You paste that prompt into your coding CLI or agent.
-4. The agent edits the repository.
-5. DevCouncil verifies the resulting diff against task constraints.
-6. If verification fails, DevCouncil creates a focused repair loop.
+```bash
+# Build the repository map (.devcouncil/repo_map.json) and code graph
+devmap build --manifest
 
-The detailed task-by-task workflow lives in [docs/workflow.md](docs/workflow.md).
+# Shorthand via the Go host:
+dev map
 
-## Install From Source
+# Query symbol blast radius & reverse dependents before editing
+devmap impact path/to/file.go
 
-For local development inside this checkout:
+# Trace dependency paths between two symbols
+devmap trace SymbolA SymbolB
 
-```bash
-uv sync
-uv run dev --help
+# Find dead code with confidence tiers (extracted | inferred | ambiguous)
+devmap dead
+
+# Launch the interactive HTML visualizer
+devmap view
 ```
 
-For a global install from this repository:
+### 4. Task Leases & Gated Verification (`devcouncil verify`)
+
+Prevent multi-agent file trampling and verify diff correctness against deterministic criteria:
 
 ```bash
-uv tool install --force .
-dev --help
-devcouncil --help
+# Run deterministic verification against a task's diff
+devcouncil verify TASK-001
+
+# Machine-readable output for agent loops
+devcouncil verify TASK-001 --json
+
+# Sandbox flag is recorded only; docker/nix do not isolate (TASK-P7-2)
+devcouncil verify TASK-001 --sandbox local
 ```
 
-## Project Shape
+Verification today (Go `verify.Run()`) enforces:
+- **Planned file scope:** Rejects unauthorized edits outside declared task boundaries.
+- **Orphan diffs / dependency-risk:** Flags files changed that were not planned.
+- **Expected tests / allowed commands:** Runs the task's command list via `/bin/sh -c` in the project root.
+- **Typed `next_actions`:** Structured repair instructions when those gates fail.
 
-DevCouncil implements a 7-phase software-team workflow:
+Stub detection, secret scanning, and coverage intersection live in the **`dcverify`** binary. `devcouncil verify`, MCP `devcouncil_verify_task`, and **Manvi** `runRigor` all spawn it. When `dcverify` is not installed the report carries an empty `rigor_applied` **and** a `rigor_skipped_reason` naming what to install — never a silent clean pass. Diff↔coverage runs only when a profile is supplied (`devcouncil verify --coverage PATH`); otherwise `coverage_skipped_reason` says so.
 
-1. Goal analysis and repository mapping.
-2. Requirements drafting.
-3. Council debate and task arbitration.
-4. Gated execution with scoped files and commands.
-5. Deterministic verification.
-6. Repair-loop generation.
-7. Evidence reporting.
+### 5. MCP Servers for AI Agents
 
-Read [docs/architecture.md](docs/architecture.md) for the artifact graph, gating state machine, and component layout.
+DevCouncil provides two complementary Model Context Protocol (MCP) servers:
 
-## Contributions
+- **Host MCP Server (`devcouncil mcp`)**: Eight tools — checkout / renew / release / next_task / get_diff / verify_task / get_gaps / policy_check_write. `verify_task` runs Go `verify.Run()`, which spawns `dcverify` for the stub and secret gates; diff↔coverage needs a profile this tool has no field for, so use `devcouncil verify --coverage PATH`.
+- **DevMap MCP Server (`devmap mcp`)**: Eleven query tools (status, search, dependencies, impact, trace, neighbors, dead_symbols, clones, preview, explore, affected_tests). Always pass `repo_path`.
 
-Project ideas and execution patterns come from the open-source ecosystem:
+---
 
-- [Sage](https://github.com/usetig/sage): peer-review-first model for planning and critique.
-- [karpathy/llm-council](https://github.com/karpathy/llm-council): for the multi-LLM peer-review pattern.
-- [GPT Pilot](https://github.com/Pythagora-io/gpt-pilot): for role-based software-team concept.
-- [astral-sh/uv](https://github.com/astral-sh/uv): for reproducible Python package/runtime workflows.
-- [OpenHands](https://github.com/All-Hands-AI/OpenHands): for workspace-aware agent execution patterns.
-- [mini-SWE-agent](https://github.com/SWE-agent/mini-swe-agent): for lightweight execution loop inspiration.
-- [SWE-agent](https://github.com/SWE-agent/SWE-agent): for full-spectrum autonomous SWE-style tasking patterns.
-- [GitNexus](https://github.com/abhigyanpatwari/GitNexus): for structural codebase awareness.
-- [graphify](https://github.com/safishamsi/graphify): for knowledge-graph-based coordination concepts.
+## Architecture Flow
+
+```mermaid
+flowchart TD
+    subgraph Agents["Harnesses, hosts, and coding agents"]
+        Claude["Claude Code"]
+        Cursor["Cursor"]
+        Codex["Codex"]
+        AGY["Antigravity"]
+        Warp["Warp"]
+        Manvi["Manvi (wraps these components)"]
+        GitPulse["GitPulse (selects modules)"]
+    end
+
+    subgraph Host["Go Host Orchestrator (devcouncil / dev)"]
+        CLI["Host CLI\ncmd/devcouncil"]
+        MCP["Host MCP Server\ndevcouncil mcp"]
+        Integ["Integrator\ndevcouncil integrate"]
+        Skills["Skills Engine\ndevcouncil skills"]
+        VerifyCmd["Verify Command\ndevcouncil verify"]
+    end
+
+    subgraph RustAnalysis["Rust Analysis & State Suite"]
+        DevMap["devmap\nCode Graph & 36+ Language ASTs"]
+        DCStore["dcstore\nAtomic Task Leases & SQLite Store"]
+        DCVerify["dcverify\nUnified Diff Parser & Rigor Gates"]
+        DCGrep["dcgrep\nRipgrep Engine & Trigram Index"]
+    end
+
+    Agents <-->|MCP Protocol| MCP
+    Agents <-->|Direct / Tool Calls| CLI
+    Manvi -->|Wraps: imports Go, spawns binaries| Host
+    Manvi -->|Spawns selected modules| RustAnalysis
+    GitPulse -->|Vendors selected crates| DevMap
+    GitPulse -->|manvi serve| Manvi
+
+    CLI -->|Execs| DevMap
+    CLI -->|Integrates| Integ
+    CLI -->|Scaffolds| Skills
+    VerifyCmd -->|Scope, orphan, expected tests| DCStore
+    Manvi -->|Spawns dcverify rigor| DCVerify
+
+    MCP -->|Leases and tasks| DCStore
+    MCP -->|verify_task → Go Run| VerifyCmd
+```
 
-## License
+---
 
-Licensed under the **Apache License, Version 2.0**. See [LICENSE](LICENSE) for details.
+## Repository Layout
+
+```
+DevCouncil/
+├── backend/go_orchestrator/     # Go host orchestrator binary and packages
+│   ├── cmd/devcouncil/          # Main entrypoint for devcouncil and dev
+│   ├── devcouncil/              # MCP server, integrate, skills, verify implementations
+│   ├── dc/store/                # Interop client for dcstore binary
+│   └── policy/                  # File-write containment & security policies
+├── rust/                        # Analysis and verification engine crates (dcstore, dcverify, dcgrep, devmap)
+├── bin/                         # Node.js npm shim (bin/devcouncil.js)
+├── scripts/                     # Platform installers (install.sh, install-components.sh)
+└── docs/                        # Architecture, releases, and integration guides
+```
 
 ---
 
-**"Trust the model, but verify the graph."**
+## Documentation
+
+- [Release Notes (v0.2.0)](docs/releases/v0.2.0.md): Native orchestration and analysis migration.
+- [Native cutover follow-ups](docs/TODO.md): Open wiring and honesty work after Phase 7.
+- [Architecture Decisions & Python Retirement](docs/PHASE7_LONG_TAIL.md): Background on the transition to native Go and Rust binaries.
+- [Archived ledgers](docs/archive/README.md): Pre-cutover DevMap plans, audits, and qualification dumps.
+- [Code Graph & DevMap Guide](docs/code-graph.md): Symbol resolution, dead code, and blast radius.
+- [DevMap competitor benchmarks](docs/devmap/README.md#benchmark-comparison): Measured strengths, weaknesses, speed, memory, storage, and correctness against Graphify, Gortex, GitNexus, CodeGraph, codebase-memory-mcp, and ripgrep, with scope limits and raw evidence.
+- [Hero Loop (MCP Closed Loop)](docs/hero-loop.md): Autonomous task loop with deterministic gates.
+- [Coding CLI Integration](docs/coding-cli-integration.md): Configuring Claude, Codex, Cursor, Warp, and Antigravity.
+- [Security Model](docs/security.md): Redaction, write isolation, and containment rules.
+- [Project Status](docs/project-status.md): Subsystem maturity ledger.
+
+---
+
+## License
+
+Licensed under the **Apache License, Version 2.0**. See [LICENSE](LICENSE) for details.

package/bin/devcouncil.js

@@ -1,18 +1,129 @@
 #!/usr/bin/env node
 
+/**
+ * npm `dev` / `devcouncil` shim.
+ *
+ * Live commands belong to the Go `devcouncil` binary, including `map` /
+ * `graph` / `ast` (which that binary execs `devmap` for). This file never
+ * invokes Python or uv, and it is not a second owner of any command.
+ */
+
 const { spawnSync } = require("node:child_process");
-const { existsSync } = require("node:fs");
+const {
+  closeSync,
+  existsSync,
+  openSync,
+  readSync,
+  realpathSync,
+  statSync,
+} = require("node:fs");
 const path = require("node:path");
 
-const packageRoot = path.resolve(__dirname, "..");
-const pyproject = path.join(packageRoot, "pyproject.toml");
+const WIN32 = process.platform === "win32";
+
+function localBinDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return home ? path.join(home, ".local", "bin") : "";
+}
+
+function isSelf(file) {
+  try {
+    return realpathSync(file) === realpathSync(__filename);
+  } catch {
+    return path.resolve(file) === path.resolve(__filename);
+  }
+}
+
+function looksLikeNodeShim(file) {
+  const lower = file.toLowerCase();
+  if (
+    lower.endsWith(".js") ||
+    lower.endsWith(".cmd") ||
+    lower.endsWith(".bat") ||
+    lower.endsWith(".ps1")
+  ) {
+    return true;
+  }
+  let fd;
+  try {
+    fd = openSync(file, "r");
+    const buf = Buffer.alloc(160);
+    const n = readSync(fd, buf, 0, 160, 0);
+    const line = buf.slice(0, n).toString("utf8").split(/\r?\n/, 1)[0] || "";
+    if (line.startsWith("#!") && /\bnode\b/i.test(line)) {
+      return true;
+    }
+  } catch {
+    return false;
+  } finally {
+    if (fd !== undefined) {
+      closeSync(fd);
+    }
+  }
+  return false;
+}
+
+function isNativeBin(file) {
+  if (!file || !existsSync(file)) {
+    return false;
+  }
+  try {
+    if (statSync(file).isDirectory()) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  if (isSelf(file) || looksLikeNodeShim(file)) {
+    return false;
+  }
+  return true;
+}
+
+function resolveBin(name, envKey) {
+  const override = process.env[envKey];
+  if (override) {
+    return override;
+  }
+  const dirs = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+  const local = localBinDir();
+  if (local) {
+    dirs.push(local);
+  }
+  const exts = WIN32 ? [".exe", ".com", ""] : [""];
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const candidate = path.join(dir, name + ext);
+      if (isNativeBin(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+
+function spawnEnv() {
+  const env = { ...process.env };
+  const local = localBinDir();
+  if (local && existsSync(local)) {
+    const current = env.PATH || env.Path || "";
+    const parts = current.split(path.delimiter);
+    if (!parts.includes(local)) {
+      env.PATH = `${local}${path.delimiter}${current}`;
+      if (WIN32) {
+        env.Path = env.PATH;
+      }
+    }
+  }
+  return env;
+}
 
 function run(command, args) {
   return spawnSync(command, args, {
     cwd: process.cwd(),
     stdio: "inherit",
-    shell: process.platform === "win32",
-    env: process.env,
+    shell: false,
+    env: spawnEnv(),
   });
 }
 
@@ -21,42 +132,29 @@ function fail(message) {
   process.exit(1);
 }
 
-function ensureUv() {
-  const check = spawnSync("uv", ["--version"], {
-    stdio: "ignore",
-    shell: process.platform === "win32",
-  });
-
-  if (check.status === 0) {
-    return;
-  }
-
+function missing(name, hint) {
   fail(
     [
-      "DevCouncil requires uv to run from the npm package.",
-      "Install uv first:",
-      "  macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh",
-      '  Windows:     powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"',
-      "",
-      "Then rerun:",
-      "  devcouncil --help",
+      `DevCouncil requires the ${name} binary on PATH (or ~/.local/bin).`,
+      hint,
     ].join("\n")
   );
 }
 
-if (!existsSync(pyproject)) {
-  fail(
-    "DevCouncil npm package is missing pyproject.toml. Reinstall the package and try again."
+const args = process.argv.slice(2);
+
+const goBin = resolveBin("devcouncil", "DEVCOUNCIL_BIN");
+if (!goBin) {
+  missing(
+    "devcouncil",
+    WIN32
+      ? "Build: go -C backend/go_orchestrator build -o %USERPROFILE%\\.local\\bin\\devcouncil.exe ./cmd/devcouncil\nAlso copy it to %USERPROFILE%\\.local\\bin\\dev.exe (scripts/install.ps1)."
+      : "Build: go -C backend/go_orchestrator build -o ~/.local/bin/devcouncil ./cmd/devcouncil\nAlso: ln -sf devcouncil ~/.local/bin/dev"
   );
 }
 
-ensureUv();
-
-const args = process.argv.slice(2);
-const result = run("uv", ["run", "--project", packageRoot, "devcouncil", ...args]);
-
+const result = run(goBin, args);
 if (result.error) {
-  fail(`Failed to start DevCouncil: ${result.error.message}`);
+  fail(`Failed to start devcouncil: ${result.error.message}`);
 }
-
 process.exit(result.status ?? 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devcouncil",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Gated orchestrator for AI-assisted software development",
   "license": "Apache-2.0",
   "homepage": "https://github.com/bharathvbcr/DevCouncil#readme",
@@ -25,21 +25,17 @@
   },
   "files": [
     "bin/",
-    "src/**/*.py",
-    "src/**/*.md",
-    "pyproject.toml",
-    "uv.lock",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "install:dev": "uv tool install --force .",
-    "install:editable": "uv pip install -e .",
-    "dev": "uv run devcouncil",
     "pack:check": "npm pack --dry-run",
-    "test": "uv run pytest",
-    "lint": "uv run ruff check .",
-    "check": "uv run ruff check . && uv run pytest"
+    "smoke:package": "node scripts/npm-runtime-smoke.mjs",
+    "smoke:registry": "node scripts/npm-registry-smoke.mjs",
+    "check:release": "node scripts/check-release.mjs",
+    "check:workflows": "node scripts/check-workflows.mjs",
+    "test:scripts": "node --test scripts/check-release.test.mjs scripts/check-workflows.test.mjs",
+    "ci:local": "node scripts/ci-local.mjs"
   },
   "engines": {
     "node": ">=18"

package/pyproject.toml

@@ -1,34 +0,0 @@
-[project]
-name = "devcouncil"
-version = "0.1.1"
-description = "Gated orchestrator for AI-assisted software development"
-readme = "README.md"
-requires-python = ">=3.12"
-dependencies = [
-    "typer>=0.12.3",
-    "rich>=13.7.1",
-    "pydantic>=2.7.1",
-    "pyyaml>=6.0.1",
-    "sqlmodel>=0.0.19",
-    "httpx>=0.27.0",
-    "gitpython>=3.1.43",
-    "mcp>=1.27.0",
-]
-
-[project.scripts]
-dev = "devcouncil.cli.main:app"
-devcouncil = "devcouncil.cli.main:app"
-
-[dependency-groups]
-dev = [
-    "pytest>=8.2.0",
-    "ruff>=0.4.4",
-    "mypy>=1.10.0",
-]
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"

package/src/devcouncil/__main__.py

@@ -1,4 +0,0 @@
-from devcouncil.cli.main import app
-
-if __name__ == "__main__":
-    app()