dev-harness-cli 1.0.5 → 1.2.0

package/README.md

@@ -1,298 +1,226 @@
+<div align="center">
+
 # Dev Harness
 
-**Agent-agnostic development pipeline CLI.** Scaffold, phase orchestrate, gate validate, and iterate any software project — works with any coding agent (Claude Code, Codex, OpenCode, Cursor, etc.).
+### Agent-agnostic development pipeline CLI
+
+Scaffold · Phase orchestration · Gate validation · Iteration
+
+[![npm version](https://img.shields.io/npm/v/dev-harness-cli.svg)](https://www.npmjs.com/package/dev-harness-cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js >=18](https://img.shields.io/badge/node-%3E%3D18-green.svg)](https://nodejs.org)
+[![Zero Dependencies](https://img.shields.io/badge/dependencies-zero-blue.svg)](#)
+
+**Works with any coding agent:** Claude Code · Codex · Cursor · Aider · Continue · OpenCode · Windsurf · Gemini · GitHub Copilot · Cline · Roo · Kilo Code · Amazon Q · and more
+
+</div>
+
+---
+
+## What is this?
+
+**Dev Harness** is a CLI tool that brings structure to AI-assisted software development. Instead of ad-hoc prompting, it enforces a **phase pipeline** with **gate validation** — ensuring specs are written before code, code is reviewed before shipping, and nothing gets skipped.
 
-```bash
-npx dev-harness-cli init --stack python --target my-project
-cd my-project
-npx dev-harness-cli phase define
 ```
+define → plan → build → verify → [simplify] → review → ship
+```
+
+Each phase has **deterministic gates** (checks) that must pass before advancing. The agent does the work; harness validates the result.
 
 ## Install
 
 ```bash
 # Quick start (no install)
-npx dev-harness-cli --help
+npx dev-harness-cli init --stack python --target my-project
 
 # Global install
 npm install -g dev-harness-cli
-harness-dev --help
-
-# Or clone and install
-git clone https://github.com/bakr-bagaber/dev-harness.git
-cd dev-harness && npm install -g .
+dev-harness --help
 ```
 
-Requires **Node.js >= 18**.
+Requires **Node.js >= 18**. Zero runtime dependencies.
 
 ## Quick Start
 
 ```bash
-# Scaffold a new project
-harness-dev init --stack python --target my-app
-
-# Check status
+# 1. Scaffold a new project
+dev-harness init --stack node --target my-app
 cd my-app
-harness-dev status
 
-# Start the DEFINE phase
-harness-dev phase define
+# 2. Check status
+dev-harness status
+
+# 3. Run the DEFINE phase (agent writes specs)
+dev-harness phase define
+
+# 4. Validate (run gate checks)
+dev-harness validate
+
+# 5. Continue through pipeline
+dev-harness phase plan
+dev-harness phase build
+dev-harness phase verify
+dev-harness phase review
+dev-harness phase ship
+```
+
+## Project Structure
+
+When you run `dev-harness init`, all harness-managed files go into a `harness/` subfolder — keeping your project root clean:
+
+```
+my-project/
+├── AGENTS.md                 # Agent instructions (root — tools expect it here)
+├── .gitignore                # Git ignore rules
+├── package.json              # Your project's package file
+├── src/                      # Your source code
+├── tests/                    # Your tests
+└── harness/                  # All harness-managed files
+    ├── config.json           # Harness configuration + state
+    ├── progress.md           # Session state + lessons learned
+    ├── sprint-contract.md    # Pre-build agreement
+    ├── evaluator-rubric.md   # Quality scorecard
+    ├── session-handoff.md    # Context for session transitions
+    ├── clean-state-checklist.md
+    ├── features/
+    │   ├── feature-list.json       # Feature tracking
+    │   └── feature-list.schema.json
+    ├── docs/
+    │   ├── ARCHITECTURE.md         # Architecture decisions
+    │   ├── CONSTRAINTS.md          # Technical constraints
+    │   ├── DECISIONS.md            # Decision log
+    │   ├── api-patterns.md         # API conventions
+    │   ├── agents/                 # Agent role guides
+    │   │   ├── planner.md
+    │   │   ├── generator.md
+    │   │   ├── evaluator.md
+    │   │   └── simplifier.md
+    │   └── phases/                 # Phase instructions
+    │       ├── define.md
+    │       ├── plan.md
+    │       ├── build.md
+    │       ├── verify.md
+    │       ├── simplify.md
+    │       ├── review.md
+    │       └── ship.md
+    ├── ci/
+    │   ├── github-actions.yml
+    │   └── gitlab-ci.yml
+    └── scripts/
+        ├── init.sh
+        └── init.ps1
 ```
 
 ## Supported Stacks
 
-| Stack | Detection | Config File |
-|-------|-----------|-------------|
-| Python | `pyproject.toml`, `setup.py`, `*.py` | `pyproject.toml` |
-| Java | `pom.xml`, `build.gradle`, `*.java` | `pom.xml` |
-| Kotlin | `build.gradle.kts`, `*.kt` | `build.gradle.kts` |
+31 built-in stacks + custom stack support:
+
+| Stack | Detection Files | Config File |
+|-------|----------------|-------------|
 | Node.js | `package.json`, `*.js`, `*.ts` | `package.json` |
-| Go | `go.mod`, `*.go` | `go.mod` |
+| Python | `pyproject.toml`, `setup.py`, `*.py` | `pyproject.toml` |
 | Rust | `Cargo.toml`, `*.rs` | `Cargo.toml` |
-| C | `*.c` | `CMakeLists.txt` |
-| C++ | `*.cpp`, `*.hpp` | `CMakeLists.txt` |
+| Go | `go.mod`, `*.go` | `go.mod` |
+| Java | `pom.xml`, `build.gradle`, `*.java` | `pom.xml` |
+| C/C++ | `*.c`, `*.cpp`, `*.hpp` | `CMakeLists.txt` |
 | .NET | `*.cs`, `*.fs` | `global.json` |
-| MATLAB | `*.m` | (none) |
-| VHDL | `*.vhdl`, `*.vhd` | (none) |
-| Verilog | `*.v`, `*.sv` | (none) |
-| Generic | fallback | (none) |
+| Ruby | `Gemfile`, `*.rb` | `Gemfile` |
+| PHP | `composer.json`, `*.php` | `composer.json` |
+| Swift | `Package.swift`, `*.swift` | `Package.swift` |
+| + 21 more | | |
+
+**Custom stacks:** Pass any name to `--stack` and fill `stackMeta` in `harness/config.json` during DEFINE phase.
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
-| `init` | Scaffold project (21 files) |
-| `status` | Show current state |
-| `phase <name>` | Invoke a phase |
-| `validate` | Run gate checks |
-| `config get/set` | Read/write config |
-| `learn <msg>` | Save a lesson |
-| `set-mode` | copilot / autopilot |
-| `pause` / `resume` | Control autopilot |
+| `init` | Scaffold a new project with harness structure |
+| `status` | Show current phase, stack, features, gates |
+| `phase <name>` | Invoke a pipeline phase |
+| `validate` | Run gate checks for current phase |
+| `config list` | List all 29 configurable parameters |
+| `config get <key>` | Get a config value |
+| `config set <key> <value>` | Set a config value |
+| `set-mode <copilot\|autopilot>` | Switch execution mode |
+| `pause` / `resume` | Pause/resume autopilot |
 | `contract propose/review/status/escalate` | Sprint contract negotiation |
-| `worktree create/list/prune/remove` | Git worktree management |
-| `checkpoint create <label>` | Git tag checkpoint |
-| `rollback list/to/branch` | Rollback to checkpoint |
+| `learn <message>` | Save a lesson to progress.md |
+| `checkpoint create <label>` | Create a manual checkpoint |
+| `rollback list/to/branch` | Restore to checkpoint |
+| `worktree create/list/remove` | Git worktree management |
+| `detect-tool` | Detect available agent tools |
 
-## Phase Pipeline
+## Agent Tool Integration
 
-```
-INIT → DEFINE → PLAN → BUILD → VERIFY → [SIMPLIFY] → REVIEW → SHIP
-```
+Harness works with any coding agent. Use `--agent-tool` during init to generate tool-specific files:
 
-Two loop modes:
-- **Copilot** (default): one phase at a time, human decides when to advance
-- **Autopilot**: auto-advances through pipeline after each gate passes
-
-## Output Contracts
+```bash
+# Claude Code → generates CLAUDE.md
+dev-harness init --stack node --agent-tool claude-code --target my-app
 
-All commands produce machine-parseable JSON with `--json`:
+# Cursor → generates .cursorrules
+dev-harness init --stack node --agent-tool cursor --target my-app
 
-```json
-{"command":"status","status":"ok","message":"Phase: define, Stack: Node.js",
- "currentPhase":"define","mode":"copilot","recentLessons":[]}
+# GitHub Copilot → generates .github/copilot-instructions.md
+dev-harness init --stack node --agent-tool copilot --target my-app
 ```
 
-Errors go to stderr: `{"error":"CliError","message":"...","exitCode":N}`
-
-Exit codes: `0` success, `1` validation failure, `2` usage error, `3` internal error
+**18 supported tools:** claude-code, cursor, windsurf, gemini, copilot, cline, roo, kilo-code, amazon-q, codex, opencode, continue, aider, antigravity, openclaw, pi, hermes, generic.
 
-## Architecture
+See [docs/TOOL_INTEGRATION.md](docs/TOOL_INTEGRATION.md) for per-tool setup guides.
 
-```
-cli/
-├── harness-dev.mjs        — Entry point + command router
-├── lib/
-│   ├── args.mjs           — Argument parser
-│   ├── errors.mjs         — Error handling + exit codes
-│   ├── help.mjs           — Help text + per-command help
-│   ├── detect-stack.mjs   — 13-stack detection engine
-│   ├── vars.mjs           — Stack variable resolution
-│   ├── templates.mjs      — Template engine ({{VAR}} substitution)
-│   ├── state.mjs          — Config I/O + phase transitions
-│   ├── phases.mjs         — Pure phase pipeline logic
-│   ├── progress.mjs       — progress.md reader/writer
-│   ├── gates.mjs          — Phase gate validation
-│   ├── ralph-inner.mjs    — Inner loop engine
-│   ├── ralph-outer.mjs    — Outer loop engine
-│   ├── ralph-output.mjs   — Phase instruction text builders
-│   ├── modes.mjs          — Copilot/autopilot modes
-│   ├── contract.mjs       — Sprint contract negotiation
-│   ├── git.mjs            — Centralized git operations
-│   ├── paths.mjs          — Centralized path resolution
-│   ├── file-io.mjs        — JSON/text I/O helpers
-│   ├── output.mjs         — JSON/human output helpers
-│   ├── command-helpers.mjs— Shared arg parsing + phaseLabel
-│   ├── constants.mjs      — Centralized magic numbers
-│   ├── scaffold.mjs       — Stack-specific scaffolding assets
-│   ├── validate-schema.mjs— Minimal JSON-schema validator
-│   └── schemas/
-│       └── stacks.json    — 13-stack metadata (CLI-internal)
-├── commands/              — 13 command handlers
-│   ├── init.mjs, status.mjs, phase.mjs, validate.mjs, config.mjs
-│   ├── learn.mjs, set-mode.mjs, pause.mjs, resume.mjs
-│   └── contract.mjs, worktree.mjs, rollback.mjs, checkpoint.mjs
-templates/                  — Scaffold templates (AGENTS.md, init.sh, ci/, docs/, etc.)
-schema/                     — Published JSON schemas (harness-config, feature-list)
-test/                       — Test suites (test-t*.mjs + run-all.mjs)
-dist/install.sh             — One-liner installation script (curl-pipe-bash)
-adapters/                  — Tool adapters (claude-code, cursor, codex, hermes, generic)
-docs/                      — TOOL_INTEGRATION.md (per-tool setup guides)
-references/                 — Historical audit reports
-history/                    — Project audit log, changelog, decisions, issues
-docs-site-templates/        — Docusaurus/Sphinx scaffolds (experimental)
-```
+## Gates
 
-## Agent Integration
-
-harness-dev works with any coding agent via stdout JSON contracts and AGENTS.md project conventions. Use `--agent-tool` at scaffold time to generate tool-specific files, or `detect-tool` to discover which tools are configured.
+Gates are deterministic checks that must pass before advancing to the next phase. Enable with:
 
 ```bash
-# Scaffold with a specific tool
-harness-dev init --stack node --agent-tool claude-code --target my-project
-
-# Or scaffold generically (AGENTS.md only — works with most tools)
-harness-dev init --stack node --target my-project
-
-# Detect which tools are configured
-harness-dev detect-tool --target my-project
+dev-harness config set gates.enabled true
 ```
 
-**Supported tools:** `claude-code` (CLAUDE.md), `cursor` (.cursorrules), `codex`, `aider`, `continue`, `opencode` (all read AGENTS.md), `hermes` (SKILL.md), `generic` (default).
+| Phase | Gates |
+|-------|-------|
+| DEFINE | feature-branch, contract-agreed |
+| PLAN | git-clean |
+| BUILD | (coverage if enabled) |
+| VERIFY | (coverage if enabled) |
+| SIMPLIFY | git-clean, no-empty-dirs |
+| REVIEW | branch-up-to-date, rubric-exists, readme-exists, architecture-doc, decisions-logged |
+| SHIP | git-clean, tagged, changelog, readme-exists, license-exists, changelog-content, contributing-exists, no-empty-dirs |
 
-See [docs/TOOL_INTEGRATION.md](docs/TOOL_INTEGRATION.md) for per-tool setup guides and the adapter architecture.
+## Configuration
 
-### Claude Code
+All configuration lives in `harness/config.json`. View with:
 
 ```bash
-harness-dev init --stack node --agent-tool claude-code --target my-project
-cd my-project
-# Claude reads CLAUDE.md automatically
-harness-dev phase build
-# Claude follows the phase instructions, runs:
-harness-dev validate
+dev-harness config list
 ```
 
-### Codex CLI
+29 parameters across 8 groups: Execution, Stack, Agent Tool, Gates, Git, Phases, Agent Tones, Runtime State.
 
-```bash
-harness-dev init --stack go --agent-tool codex --target my-project
-cd my-project
-# Codex reads AGENTS.md from project root
-harness-dev status --json
-# → Machine-readable state for agent decision-making
-```
-
-### Cursor
+See [docs/CONFIGURATION.md](docs/CONFIGURATION.md) for full reference.
 
-```bash
-harness-dev init --stack rust --agent-tool cursor --target my-project
-cd my-project
-# .cursorrules generated with harness conventions
-harness-dev phase build
-```
+## JSON Output
 
-### Generic Agent Workflow
+All commands support `--json` for machine-parseable output:
 
 ```bash
-harness-dev phase build
-# → Prints task instructions for agent
-# → Agent reads AGENTS.md + progress.md + sprint-contract.md
-# → Agent implements → calls `harness-dev validate`
-# → Gate passes → `harness-dev phase verify`
+dev-harness status --json
+dev-harness phase define --json
+dev-harness validate --json
 ```
 
-## API Reference
-
-### JSON Output Contract (all commands)
-
 ```json
 {
-  "command": "<command_name>",
-  "status": "ok" | "not_implemented" | "error",
-  "message": "Human-readable status or error detail"
+  "command": "status",
+  "status": "ok",
+  "currentPhase": "define",
+  "stack": "node",
+  "mode": "copilot"
 }
 ```
 
-Additional command-specific fields are included (e.g. `currentPhase`, `stack`, `mode`).
-
-### Error Contract
-
-```json
-{
-  "error": "CliError",
-  "message": "Description of the problem",
-  "exitCode": 1
-}
-```
-
-Errors always go to **stderr** so stdout stays parseable.
-
-### Exit Codes
-
-| Code | Meaning |
-|------|---------|
-| 0 | Success |
-| 1 | Validation failure |
-| 2 | Usage error |
-| 3 | Internal error |
-
-### All Commands
-
-| Command | JSON Fields | Description |
-|---------|-------------|-------------|
-| `init` | `project`, `stack`, `filesCreated` | Scaffold harness project |
-| `status` | `currentPhase`, `mode`, `stack`, `gateStatus`, `checksPassing`, `checksTotal`, `recentLessons`, `nextAction` | Show current state |
-| `phase <name>` | `phase`, `previousPhase`, `gateResult`, `iteration` | Invoke a phase |
-| `validate` | `phase`, `checks[]`, `overall`, `failures[]` | Run gate checks |
-| `config get <key>` | `key`, `value` | Read config value |
-| `config set <key> <value>` | `key`, `previous`, `current` | Write config value |
-| `learn <msg>` | `lesson` | Append a lesson |
-| `set-mode copilot\|autopilot` | `previous`, `current` | Switch mode |
-| `pause` / `resume` | `paused` | Control autopilot |
-| `contract propose\|review\|status\|escalate` | `status`, `agreed`, `round`, `pinned` | Sprint contract |
-| `worktree create\|list\|prune\|remove` | `worktrees[]`, `action`, `name` | Git worktree |
-| `checkpoint create <label>` | `tag`, `commit` | Git checkpoint |
-| `rollback list\|to\|branch` | `checkpoints[]`, `restored` | Rollback |
-
-## Project Structure
-
-```
-cli/                        — CLI source
-├── harness-dev.mjs         — Entry point + command router
-├── lib/                    — Core libraries
-│   ├── git.mjs             — Centralized git operations
-│   ├── state.mjs           — Config I/O + phase transitions (re-exports phases.mjs)
-│   ├── phases.mjs          — Pure phase pipeline logic
-│   ├── ralph-inner.mjs     — Inner loop (work → validate → retry)
-│   ├── ralph-outer.mjs     — Outer loop (phase auto-advance)
-│   ├── ralph-output.mjs    — Phase instruction text builders
-│   ├── gates.mjs           — Phase gate validation
-│   ├── contract.mjs        — Sprint contract negotiation
-│   ├── paths.mjs           — Centralized path resolution
-│   ├── file-io.mjs         — JSON/text I/O helpers
-│   ├── output.mjs          — JSON/human output helpers
-│   ├── command-helpers.mjs — Shared arg parsing + phaseLabel
-│   ├── constants.mjs       — Centralized magic numbers
-│   ├── scaffold.mjs        — Stack-specific scaffolding assets
-│   ├── templates.mjs       — Template engine
-│   ├── detect-stack.mjs    — Stack detection
-│   ├── validate-schema.mjs — Minimal JSON-schema validator
-│   └── schemas/stacks.json — Stack metadata (CLI-internal)
-├── commands/               — Command handlers (13 commands)
-templates/                  — Scaffold templates (AGENTS.md, init.sh, ci/, docs/, etc.)
-schema/                     — Published JSON schemas (harness-config, feature-list)
-test/                       — Test suites (test-t*.mjs + run-all.mjs)
-dist/install.sh             — One-liner install script
-adapters/                  — Tool adapters (claude-code, cursor, codex, hermes, generic)
-docs/                      — TOOL_INTEGRATION.md (per-tool setup guides)
-references/                 — Historical audit reports (T5-T14)
-history/                    — Project audit log, changelog, decisions, issues
-docs-site-templates/        — Docusaurus/Sphinx scaffolds (experimental, T25)
-PROJECT_PLAN.md             — Full task breakdown (T1-T20)
-SPEC.md                     — Original architecture specification
-dev-harness.md              — Internal project note (Obsidian)
-```
+Errors go to stderr. Exit codes: `0` success, `1` validation, `2` usage, `3` internal.
 
 ## License
 

package/cli/commands/checkpoint.mjs

@@ -9,7 +9,7 @@
  * save named recovery points (e.g. "before-refactor") that appear
  * in `rollback list` and can be used with `rollback to/branch`.
  *
- * Usage: harness-dev checkpoint create <label>
+ * Usage: dev-harness checkpoint create <label>
  */
 import { die, CliError, EXIT } from '../lib/errors.mjs';
 import { execGit, getGitRoot, gitTagExists, createGitTag } from '../lib/git.mjs';
@@ -21,7 +21,7 @@ export default async function checkpointCommand(args) {
   const label = args.positionals[0];
 
   if (sub !== 'create' || !label) {
-    die(new CliError('Usage: harness-dev checkpoint create <label> [--force]', EXIT.USAGE_ERROR), json);
+    die(new CliError('Usage: dev-harness checkpoint create <label> [--force]', EXIT.USAGE_ERROR), json);
     return;
   }
 

package/cli/commands/config.mjs

@@ -4,16 +4,16 @@
  * Uses state.mjs for dot-notation read/write with persistence.
  *
  * Usage:
- *   harness-dev config list              — list all parameters with descriptions
- *   harness-dev config get [key]         — get a value or all config
- *   harness-dev config set <key> <value> — set a value
+ *   dev-harness config list              — list all parameters with descriptions
+ *   dev-harness config get [key]         — get a value or all config
+ *   dev-harness config set <key> <value> — set a value
  *
  * Examples:
- *   harness-dev config list
- *   harness-dev config list --json
- *   harness-dev config get gates.enabled
- *   harness-dev config set gates.enabled true
- *   harness-dev config set maxRetries 5
+ *   dev-harness config list
+ *   dev-harness config list --json
+ *   dev-harness config get gates.enabled
+ *   dev-harness config set gates.enabled true
+ *   dev-harness config set maxRetries 5
  */
 import { resolve } from 'node:path';
 import { die, CliError, EXIT } from '../lib/errors.mjs';
@@ -29,7 +29,7 @@ export default async function configCommand(args) {
 
   if (!sub || (sub !== 'get' && sub !== 'set' && sub !== 'list')) {
     die(new CliError(
-      'Usage: harness-dev config list | config get [key] | config set <key> <value>',
+      'Usage: dev-harness config list | config get [key] | config set <key> <value>',
       EXIT.USAGE_ERROR,
     ), json);
     return;
@@ -75,7 +75,7 @@ export default async function configCommand(args) {
     // Human output — grouped table
     process.stdout.write('═══ Harness Configuration ═══\n\n');
     if (!ok) {
-      process.stdout.write('  No harness-config.json found. Run: harness-dev init\n\n');
+      process.stdout.write('  No harness/config.json found. Run: dev-harness init\n\n');
       return;
     }
 
@@ -102,7 +102,7 @@ export default async function configCommand(args) {
       process.stdout.write('\n');
     }
 
-    process.stdout.write('Edit with: harness-dev config set <key> <value>\n');
+    process.stdout.write('Edit with: dev-harness config set <key> <value>\n');
     process.stdout.write('Full docs: docs/CONFIGURATION.md\n');
     return;
   }
@@ -141,7 +141,7 @@ export default async function configCommand(args) {
   if (sub === 'set') {
     if (pos.length < 2) {
       die(new CliError(
-        'Usage: harness-dev config set <key> <value>\n' +
+        'Usage: dev-harness config set <key> <value>\n' +
         '  String values: config set mode copilot\n' +
         '  Boolean values: config set gates.enabled true\n' +
         '  Numeric values: config set maxRetries 5',

package/cli/commands/contract.mjs

@@ -4,10 +4,10 @@
  * Manages the generator-evaluator agreement loop.
  *
  * Usage:
- *   harness-dev contract propose [--scope "msg"] [--exclusions "msg"]
- *   harness-dev contract review [--agreed|--needs-revision]
- *   harness-dev contract status
- *   harness-dev contract escalate [--reason "msg"]
+ *   dev-harness contract propose [--scope "msg"] [--exclusions "msg"]
+ *   dev-harness contract review [--agreed|--needs-revision]
+ *   dev-harness contract status
+ *   dev-harness contract escalate [--reason "msg"]
  */
 import { resolve } from 'node:path';
 import { die, CliError, EXIT } from '../lib/errors.mjs';
@@ -22,7 +22,7 @@ export default async function contractCommand(args) {
   const sub = args.subcommand;
 
   if (!sub || !SUBCOMMANDS.includes(sub)) {
-    die(new CliError(`Usage: harness-dev contract ${SUBCOMMANDS.join('|')}`, EXIT.USAGE_ERROR), json);
+    die(new CliError(`Usage: dev-harness contract ${SUBCOMMANDS.join('|')}`, EXIT.USAGE_ERROR), json);
     return;
   }
 
@@ -34,7 +34,7 @@ export default async function contractCommand(args) {
 
     if (!scope) {
       die(new CliError(
-        'Usage: harness-dev contract propose --scope "I will build X" [--exclusions "W"] [--criteria "test1|test2"]',
+        'Usage: dev-harness contract propose --scope "I will build X" [--exclusions "W"] [--criteria "test1|test2"]',
         EXIT.USAGE_ERROR,
       ), json);
       return;
@@ -53,7 +53,7 @@ export default async function contractCommand(args) {
     }
 
     if (result.ok) {
-      process.stdout.write('✓ Contract proposed. Run: harness-dev contract review\n');
+      process.stdout.write('✓ Contract proposed. Run: dev-harness contract review\n');
     } else {
       process.stderr.write(`✗ ${result.error}\n`);
     }
@@ -68,7 +68,7 @@ export default async function contractCommand(args) {
 
     if (!agreed && !needsRevision) {
       die(new CliError(
-        'Usage: harness-dev contract review --agreed [--notes "msg"]  OR  --needs-revision [--notes "msg"]',
+        'Usage: dev-harness contract review --agreed [--notes "msg"]  OR  --needs-revision [--notes "msg"]',
         EXIT.USAGE_ERROR,
       ), json);
       return;
@@ -116,7 +116,7 @@ export default async function contractCommand(args) {
         rounds,
         message: status
           ? `Contract ${status} (round ${rounds}/5)`
-          : 'No sprint-contract.md found. Run: harness-dev contract propose',
+          : 'No sprint-contract.md found. Run: dev-harness contract propose',
       }) + '\n');
       return;
     }
@@ -124,7 +124,7 @@ export default async function contractCommand(args) {
     if (status) {
       process.stdout.write(`Contract status: ${status} (round ${rounds}/5)\n`);
     } else {
-      process.stdout.write('No sprint-contract.md found. Run: harness-dev contract propose\n');
+      process.stdout.write('No sprint-contract.md found. Run: dev-harness contract propose\n');
     }
     return;
   }

package/cli/commands/detect-tool.mjs

@@ -12,7 +12,7 @@
  * Also reads harness-config.json agentTool field if present.
  *
  * Usage:
- *   harness-dev detect-tool [--target <dir>] [--json]
+ *   dev-harness detect-tool [--target <dir>] [--json]
  */
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
@@ -20,12 +20,13 @@ import { parseCommandArgs } from '../lib/command-helpers.mjs';
 import { emitJson, emitHuman } from '../lib/output.mjs';
 import { loadConfig } from '../lib/state.mjs';
 import { getAllDetectionSignatures, AGENTS_MD_TOOLS, TOOL_REGISTRY } from '../lib/tool-registry.mjs';
+import { AGENTS_PATH } from '../lib/paths.mjs';
 
 export default async function detectToolCommand(args) {
   const { json, targetDir } = parseCommandArgs(args);
 
   const detected = [];
-  const hasAgentsMd = existsSync(resolve(targetDir, 'AGENTS.md'));
+  const hasAgentsMd = existsSync(AGENTS_PATH(targetDir));
 
   // 1. Scan for tool-specific detection files (from registry)
   for (const { tool, file } of getAllDetectionSignatures()) {
@@ -79,7 +80,7 @@ export default async function detectToolCommand(args) {
     status: 'ok',
     message: detected.length > 0
       ? `Detected ${detected.length} agent tool(s): ${detected.join(', ')}`
-      : 'No agent tools detected. Run: harness-dev init',
+      : 'No agent tools detected. Run: dev-harness init',
     available: detected,
     configured: configuredTool,
     recommended,
@@ -103,7 +104,7 @@ export default async function detectToolCommand(args) {
     }
   } else {
     emitHuman(`  No agent tools detected.\n`);
-    emitHuman(`  Run: harness-dev init to scaffold a project.\n`);
+    emitHuman(`  Run: dev-harness init to scaffold a project.\n`);
   }
   if (hasAgentsMd) {
     emitHuman(`\n  AGENTS.md present — tools that read it natively are available.\n`);