@ksuchoi216/ahe 0.1.6 → 0.1.10

package/README.md

@@ -1,216 +1,84 @@
 # Awesome Harness Engineering (AHE)
 
-AHE automatically builds and maintains project harnesses through Codex chat. It installs a set of Codex skills into your workspace, then guides you through defining your project specification, tracking features, and managing progress — all via natural conversation.
-
----
-
-## 1. Installation
-
-### Quick Start (Recommended)
-
-```bash
-npx --yes --package=@ksuchoi216/ahe ahe install
-```
-
-### Global Install
-
-```bash
-npm install -g @ksuchoi216/ahe
-ahe install
-```
-
-### Local Development
-
-After cloning the repository:
-
-```bash
-npx --yes --package=file:. ahe install
-```
-
-### CLI Commands
-
-| Command                | Description                                     |
-| ---------------------- | ----------------------------------------------- |
-| `ahe install`          | Install AHE skills into `.codex/`               |
-| `ahe install --force`  | Overwrite existing installation                 |
-| `ahe install --backup` | Backup existing installation before overwriting |
-| `ahe uninstall`        | Remove all AHE skills, shared assets, and hooks |
-| `ahe doctor`           | Check installation health and integrity         |
-| `ahe version`          | Print the current version                       |
-
----
-
-## 2. How to Use
-
-AHE works inside **Codex chat**. After installing via the terminal, open Codex chat in your workspace and type one of the commands below.
-
-### Chat Commands
-
-| Command    | What it does                                                                                                            |
-| ---------- | ----------------------------------------------------------------------------------------------------------------------- |
-| `ahe init` | **Start a new harness.** Creates harness skeleton files, asks about your project, and writes the product specification. |
-| `ahe`      | **Continue existing work.** Inspects the current state, reports status, decides the next step, and keeps working.       |
-
-> **Note:** Only exact commands trigger AHE. Normal messages like "explain ahe" or "what does ahe do" will not start any workflow.
-
-### Typical Workflow
-
-```
-# Step 1: Install AHE skills into your project
-$ ahe install
-
-# Step 2: Open Codex chat and initialize the harness
-> ahe init
-  → AHE asks about your project purpose, language, tech stack, constraints...
-  → Creates AGENTS.md, feature-list.json, PROGRESS.md, docs/PRODUCT.md, etc.
-
-# Step 3: Continue working — just type "ahe"
-> ahe
-  → AHE inspects the harness state and prints a status report
-  → Picks the next unfinished feature or asks for missing info
-  → Works on it, then updates tracking artifacts
-
-# Step 4: Keep iterating
-> ahe
-  → Reports progress, moves to the next feature
-  → Repeat until all features are done
-```
-
----
-
-## 3. How It Works
-
-### Skills Overview
-
-AHE is composed of six core skills that coordinate automatically:
-
-| Skill                | Role                                                                                                                                              |
-| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **ahe-init**         | Entry point for new projects. Creates harness files, asks for project info, then calls ahe-spec and ahe-update.                                   |
-| **ahe-thinking**     | Internal decision engine. Evaluates clarity on **Why** / **What** / **How** for each work unit and routes to the right action.                    |
-| **ahe-compression**  | Internal size detector & compressor. Monitors file sizes via configurable thresholds (`config.yaml`) and compresses bloated files before reading. |
-| **ahe-conversation** | Internal question protocol. Asks exactly one focused question at a time when information is missing.                                              |
-| **ahe-spec**         | Writes and updates `docs/PRODUCT.md` (canonical source of truth) and `docs/INSTRUCTIONS.md`.                                                      |
-| **ahe-update**       | Syncs tracking artifacts: `feature-list.json`, `PROGRESS.md`, `SESSION-HANDOFF.md`.                                                               |
-
-### Process Flow
-
-```mermaid
-flowchart TD
-    Install["<b>Terminal</b><br/>ahe install"] --> Chat["Open Codex chat<br/>in the workspace"]
-
-    Chat --> Command{"What did you type?"}
-    Command -->|"ahe init"| Init["<b>ahe-init</b><br/>New-start workflow"]
-    Command -->|"ahe"| Router["<b>AHE Router</b><br/>Inspect harness &amp; print status"]
-    Command -->|"other message"| Noop["No AHE workflow triggered"]
-
-    Router --> Classify{"Classify harness state"}
-    Classify -->|"Not enough spec"| Init
-    Classify -->|"Building features"| Feature["Continue next<br/>unfinished feature"]
-    Classify -->|"All completed"| AskNext["Ask user for<br/>the next task"]
-
-    Init --> Step1["<b>Step 1:</b> Setup<br/>AGENTS.md + templates"]
-    Step1 --> Step2["<b>Step 2: ahe-spec</b><br/>Write PRODUCT.md<br/>and INSTRUCTIONS.md"]
-    Step2 --> Step3["<b>Step 3: ahe-update</b><br/>Sync feature-list.json<br/>and PROGRESS.md"]
-    Step3 --> Done["Harness ready ✓"]
-
-    Feature --> Compression["<b>ahe-compression</b><br/>Check & compress oversized files"]
-    Compression --> Thinking["<b>ahe-thinking</b><br/>Check Why / What / How"]
-    Thinking --> Clear{"Clear enough<br/>to proceed?"}
-    Clear -->|"No"| Convo["<b>ahe-conversation</b><br/>Ask one focused question"]
-    Convo --> UserAnswer["User answers"]
-    UserAnswer --> Thinking
-    Clear -->|"Yes"| Execute["Execute the<br/>next safe step"]
-    Execute --> Update["<b>ahe-update</b><br/>Sync tracking artifacts"]
-    Update --> Done2["Ready for next<br/><code>ahe</code> command ✓"]
-```
-
-### Detailed Steps
-
-#### `ahe init` — New Start
-
-1. Scans the workspace for existing harness files.
-2. If files exist, asks the user what scope to restart (full restart, product-only, or custom).
-3. Backs up affected files to `.ahe/backups/`.
-4. Asks about project purpose, language, and tech stack.
-5. Deploys template files (`AGENTS.md`, `PROGRESS.md`, `SESSION-HANDOFF.md`, `feature-list.json`, `init.sh`).
-6. Calls **ahe-spec** → writes `docs/PRODUCT.md` and `docs/INSTRUCTIONS.md`.
-7. Calls **ahe-update** → derives features and syncs tracking artifacts.
-
-#### `ahe` — Continue Work
-
-1. Hook injects the AHE router directive into the agent context.
-2. Router inspects all harness files and prints a status table.
-3. Classifies the current state:
-   - **"Not enough spec"** → routes to `ahe-init` to fill gaps.
-   - **"Building features"** → picks the next unfinished feature from `feature-list.json`.
-   - **"All completed"** → asks the user for the next task.
-4. **ahe-thinking** checks file sizes using **ahe-compression** and compresses oversized files based on `config.yaml` thresholds.
-5. **ahe-thinking** checks clarity (Why / What / How) for the current work unit.
-6. If unclear → **ahe-conversation** asks exactly one question, then re-evaluates.
-7. If clear → executes the next safe step.
-8. **ahe-update** syncs all tracking artifacts at the end.
-
-#### Execution Loop
-
-The core loop repeats until the work unit is done:
-
-```
-thinking → conversation (if needed) → execution → thinking
-```
-
----
-
-## Project Structure
-
-After `ahe install`, the following structure is added to your workspace:
-
-```
-your-project/
-├── .codex/
-│   ├── skills/
-│   │   ├── ahe-init/           # New-start workflow skill
-│   │   ├── ahe-conversation/   # Internal question protocol
-│   │   ├── ahe-thinking/       # Internal decision engine
-│   │   ├── ahe-compression/    # Internal size detector & compressor
-│   │   ├── ahe-spec/           # Specification writer
-│   │   └── ahe-update/         # Tracking artifact syncer
-│   ├── ahe-shared/
-│   │   ├── config.yaml         # Compression thresholds & configuration
-│   │   ├── templates/          # Harness file templates
-│   │   └── schemas/            # Validation schemas
-│   └── hooks/
-│       ├── hooks.json          # Chat command trigger patterns
-│       └── ahe-hook.js         # Hook script that injects directives
-```
-
-After `ahe init`, the harness files are created in your project root:
-
-```
-your-project/
-├── docs/
-│   ├── PRODUCT.md              # Product specification (source of truth)
-│   └── INSTRUCTIONS.md         # Implementation instructions
-├── .ahe/
-│   └── process_status.json     # Workflow state persistence
-├── AGENTS.md                   # Project objectives and agent rules
-├── feature-list.json           # Feature state tracker (derived from PRODUCT.md)
-├── PROGRESS.md                 # Session continuity log
-├── SESSION-HANDOFF.md          # Handoff notes between sessions
-└── init.sh                     # Standard startup/verification script
-```
-
-## Agent Working Rules
-
-If you are an AI agent working on this repository, please strictly follow the guidelines in [AGENTS.md](AGENTS.md). It includes critical instructions regarding the definition of done, verification commands, and file modification rules (e.g., you must update `PROGRESS.md` and `feature-list.json` appropriately).
-
-## References
-
-This repository was greatly influenced by the following projects:
-
-- [oh-my-openagent](https://github.com/code-yeongyu/oh-my-openagent): Greatly influenced the code structure of this project.
-- [learn-harness-engineering](https://github.com/walkinglabs/learn-harness-engineering): Provided the harness engineering templates used in this project.
-
-## License
-
-MIT
+AHE installs global Codex and Antigravity skills that manage harness files through chat. The repository uses a one-package, two-internal-packages layout (`packages/ahe-codex` and `packages/ahe-antigravity`) shipped as a single npm package. The
+public entrypoints stay small: use `ahe new` to start or reset harness work,
+`ahe` to continue existing work, `ahe ship` to save the latest plan (in Codex) or refresh and execute a saved plan (in Antigravity),
+`ahe fix` to create a `.plans` fix plan, and
+`ahe <query>` or `<query> ahe` for explicit AHE requests such as `ahe compress`
+or `compress ahe`. For a detailed in-chat explanation of the AHE architecture and workflows, use `ahe-overview`.
+
+## Core Command Workflows
+
+Here are intuitive flow examples for the primary AHE commands. While `ahe`, `ahe-new`, `ahe-ship`, and `ahe-fix` are the explicit commands, you can also use conversational queries (e.g., `ahe add dashboard export feature`) which are automatically routed.
+
+### `ahe new` Flow
+1. **Empty Workspace**: You have a new or existing repo that needs AHE.
+2. **ahe-new calling**: You type `ahe new` in Codex.
+3. **Initialization**: It prepares the workspace, creates templates, and hands off to `ahe-harness` to sync your product docs.
+
+### `ahe ship` Flow
+1. **plan mode in codex**: Generate an implementation plan inside Codex.
+2. **ahe-ship calling in codex**: If in Plan Mode, the Codex host exits Plan Mode and replays the command. Outside Plan Mode, Codex saves the plan to `.plans/` and stops.
+3. **ahe-ship calling in antigravity**: Antigravity refreshes the saved plan against current code, executes it, and cleans it up.
+
+### `ahe fix` Flow
+1. **Error Encountered**: A test fails or intent changes after execution.
+2. **ahe-fix calling**: You type `ahe fix` (or `ahe fix stale tests`) in Codex.
+3. **Fix Plan Creation**: It generates a dedicated fix plan in `.plans/` ready for Antigravity to refresh and execute.
+
+### General `ahe` Flow
+1. **Ongoing Work**: You need to implement a feature or update docs.
+2. **ahe calling**: You type `ahe` or a specific query like `ahe update product spec` in Codex.
+3. **Automatic Routing**: `ahe-think` evaluates your request and automatically routes it to the right agent (like `ahe-solve` or `ahe-harness`).
+
+## Installed Skills
+
+| Skill | Role |
+| --- | --- |
+| `ahe` | Top-level user-facing continuation skill that routes exact `ahe` and `ahe` query forms through `ahe-think`. |
+| `ahe-new` | New-start workflow that prepares the workspace and hands product/tracking work to `ahe-harness`. |
+| `ahe-think` | Centered internal router that judges what is missing and chooses the next agent. |
+| `ahe-review` | Review agent for repo code, harness state, and CodeGraph context. |
+| `ahe-converse` | Clarification agent for recursive user conversation. |
+| `ahe-harness` | Harness-management agent for product docs, instructions, feature tracking, todo sync, and compression-aware maintenance. |
+| `ahe-feature` | Internal helper for deriving feature-list entries from product context. |
+| `ahe-fix` | Independent fix planner that writes `.plans/{plan_name}.md` for errors or changed user intent. |
+| `ahe-solve` | Feature-solving agent that divides and plans implementation work. |
+| `ahe-compress` | Internal helper that detects oversized harness files before broad reads. |
+| `ahe-overview` | Explains the AHE concept, entrypoints, and main workflows in chat with Mermaid diagrams. |
+| `ahe-ship` | In Codex: saves Plan Mode plan to `.plans/`. In Antigravity: refreshes and executes exactly one plan from `.plans/`. |
+
+## Routing Model
+
+The Codex-side model is centered but flexible:
+
+- exact `ahe` -> `ahe-think` -> `ahe-review | ahe-converse | ahe-harness | ahe-solve`
+- `ahe <query>` or `<query> ahe` -> `ahe-think` -> `ahe-review | ahe-converse | ahe-harness | ahe-solve`
+- exact `ahe new` -> dedicated new-start workflow first, then `ahe-harness`
+- exact `ahe ship` -> independent plan-export workflow (Codex) or execution workflow (Antigravity)
+- exact `ahe fix`, `ahe fix <query>`, or `<query> ahe fix` -> independent fix-plan workflow
+
+- `ahe-think` is the center of judgment.
+- Worker agents can call each other directly when that is the logical next
+  action.
+- Typical direct handoffs are `ahe-harness -> ahe-converse`,
+  `ahe-solve -> ahe-review`, and `ahe-review -> ahe-harness`.
+
+## Query Examples
+
+- `ahe`
+- `ahe new`
+- `ahe ship`
+- `ahe fix`
+- `ahe fix stale tests`
+- `stale tests ahe fix`
+- `ahe compress`
+- `compress ahe`
+- `ahe update product spec`
+- `ahe add dashboard export feature`
+
+Only exact `ahe`, exact `ahe new`, exact `ahe-new`, exact `$ahe-new`, and
+exact `ahe ship`, exact `ahe-ship`, exact `$ahe-ship`, exact `ahe fix`, exact
+exact `ahe-fix`, exact `$ahe-fix`, `ahe fix <query>`, `<query> ahe fix`,
+`ahe-overview`, `ahe <query>`, and `<query> ahe` activate the hook.
+Middle mentions that do not fit those command shapes do not.

package/bin/ahe

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-readonly VERSION="0.1.0"
+readonly VERSION="0.1.7"
 SCRIPT_PATH="${BASH_SOURCE[0]}"
 
 while [ -L "${SCRIPT_PATH}" ]; do
@@ -16,19 +16,6 @@ done
 
 readonly SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "${SCRIPT_PATH}")" && pwd)"
 readonly PACKAGE_ROOT="$(CDPATH= cd -- "${SCRIPT_DIR}/.." && pwd)"
-readonly SOURCE_SKILLS_DIR="${PACKAGE_ROOT}/.codex/skills"
-readonly SOURCE_SHARED_DIR="${PACKAGE_ROOT}/.codex/ahe-shared"
-readonly SOURCE_HOOKS_DIR="${PACKAGE_ROOT}/.codex/hooks"
-readonly AHE_CONFIG_BLOCK_START="# BEGIN AHE MANAGED CONFIG"
-readonly AHE_CONFIG_BLOCK_END="# END AHE MANAGED CONFIG"
-readonly MANAGED_SKILLS=(
-  "ahe-init"
-  "ahe-conversation"
-  "ahe-compression"
-  "ahe-thinking"
-  "ahe-spec"
-  "ahe-update"
-)
 
 usage() {
   cat <<'EOF'
@@ -40,223 +27,42 @@ Usage:
 EOF
 }
 
-backup_existing_installation() {
-  local target_dir="$1"
-  local backup_root="$2"
-  local backup_name="$3"
-  local timestamp
+dispatch() {
+  local command="$1"
+  shift
 
-  timestamp="$(date '+%Y%m%d-%H%M%S')"
-  mkdir -p "${backup_root}"
-  mv "${target_dir}" "${backup_root}/${backup_name}-${timestamp}"
-}
+  local codex_bin="${PACKAGE_ROOT}/packages/ahe-codex/bin/ahe-codex"
+  local antigravity_bin="${PACKAGE_ROOT}/packages/ahe-antigravity/bin/ahe-antigravity"
 
-cleanup_ahe_config_entries() {
-  local config_path="$1"
-  local temp_path=""
+  local codex_status=0
+  local antigravity_status=0
 
-  if [ ! -f "${config_path}" ]; then
-    return 0
+  if [ "${command}" != "doctor" ]; then
+    echo "=== Dispatching to ahe-codex ==="
   fi
-
-  temp_path="${config_path}.ahe-cleanup"
-  awk -v block_start="${AHE_CONFIG_BLOCK_START}" -v block_end="${AHE_CONFIG_BLOCK_END}" '
-    function is_ahe_header(line) {
-      return line ~ /^\[agents\."?ahe[-_][^]]*"?\]$/ ||
-        line ~ /^\[hooks\.state\."ahe[^"]*"\]$/ ||
-        line ~ /^\[plugins\."?ahe[^]]*"?\]$/ ||
-        line ~ /^\[plugins\."@ksuchoi216\/ahe[^"]*"\]$/
-    }
-
-    $0 == block_start {
-      skip = 1
-      next
-    }
-
-    $0 == block_end {
-      skip = 0
-      next
-    }
-
-    /^\[/ {
-      if (is_ahe_header($0)) {
-        skip = 1
-        next
-      }
-      skip = 0
-    }
-
-    skip != 1 {
-      print
-    }
-  ' "${config_path}" > "${temp_path}"
-  mv "${temp_path}" "${config_path}"
-}
-
-install_skill() {
-  local force="false"
-  local backup="false"
-
-  while [ "$#" -gt 0 ]; do
-    case "$1" in
-      --force)
-        force="true"
-        ;;
-      --backup)
-        backup="true"
-        ;;
-      *)
-        printf 'Unknown install option: %s\n' "$1" >&2
-        usage >&2
-        exit 1
-        ;;
-    esac
-    shift
-  done
-
-  if [ ! -d "${SOURCE_SKILLS_DIR}" ]; then
-    printf 'Packaged skill files are missing: %s\n' "${SOURCE_SKILLS_DIR}" >&2
-    exit 1
+  if [ -x "${codex_bin}" ]; then
+    "${codex_bin}" "${command}" "$@" || codex_status=$?
+  else
+    echo "Warning: ahe-codex script not found or not executable at ${codex_bin}"
+    codex_status=1
   fi
 
-  if [ ! -d "${SOURCE_SHARED_DIR}" ]; then
-    printf 'Packaged shared files are missing: %s\n' "${SOURCE_SHARED_DIR}" >&2
-    exit 1
+  if [ "${command}" != "doctor" ]; then
+    echo ""
+    echo "=== Dispatching to ahe-antigravity ==="
+  else
+    echo ""
   fi
-
-  local target_skills_dir="${PWD}/.codex/skills"
-  local target_shared_dir="${PWD}/.codex/ahe-shared"
-  local target_hooks_dir="${PWD}/.codex/hooks"
-  local target_config_path="${PWD}/.codex/config.toml"
-  local backup_dir="${PWD}/.codex/_backups"
-  local skill_name=""
-  local skill_target=""
-
-  cleanup_ahe_config_entries "${target_config_path}"
-
-  for skill_name in "${MANAGED_SKILLS[@]}"; do
-    skill_target="${target_skills_dir}/${skill_name}"
-
-    if [ -e "${skill_target}" ]; then
-      if [ "${backup}" = "true" ]; then
-        backup_existing_installation "${skill_target}" "${backup_dir}" "${skill_name}"
-      elif [ "${force}" != "true" ]; then
-        cat <<EOF >&2
-AHE skill is already installed at:
-  ${skill_target}
-
-Re-run with --force to overwrite or --backup to move the existing install aside first.
-EOF
-        exit 1
-      else
-        rm -rf "${skill_target}"
-      fi
-    fi
-  done
-
-  if [ -e "${target_shared_dir}" ]; then
-    if [ "${backup}" = "true" ]; then
-      backup_existing_installation "${target_shared_dir}" "${backup_dir}" "ahe-shared"
-    elif [ "${force}" = "true" ]; then
-      rm -rf "${target_shared_dir}"
-    else
-      cat <<EOF >&2
-AHE shared assets are already installed at:
-  ${target_shared_dir}
-
-Re-run with --force to overwrite or --backup to move the existing install aside first.
-EOF
-      exit 1
-    fi
+  if [ -x "${antigravity_bin}" ]; then
+    "${antigravity_bin}" "${command}" "$@" || antigravity_status=$?
+  else
+    echo "Warning: ahe-antigravity script not found or not executable at ${antigravity_bin}"
+    antigravity_status=1
   fi
 
-  if [ -e "${target_hooks_dir}" ]; then
-    if [ "${backup}" = "true" ]; then
-      backup_existing_installation "${target_hooks_dir}" "${backup_dir}" "hooks"
-    elif [ "${force}" = "true" ]; then
-      rm -rf "${target_hooks_dir}"
-    else
-      cat <<EOF >&2
-AHE hooks are already installed at:
-  ${target_hooks_dir}
-
-Re-run with --force to overwrite or --backup to move the existing install aside first.
-EOF
-      exit 1
-    fi
+  if [ "${codex_status}" -ne 0 ] || [ "${antigravity_status}" -ne 0 ]; then
+    return 1
   fi
-
-  mkdir -p "${target_skills_dir}"
-  for skill_name in "${MANAGED_SKILLS[@]}"; do
-    cp -R "${SOURCE_SKILLS_DIR}/${skill_name}" "${target_skills_dir}/${skill_name}"
-  done
-  cp -R "${SOURCE_SHARED_DIR}" "${target_shared_dir}"
-  cp -R "${SOURCE_HOOKS_DIR}" "${target_hooks_dir}"
-
- cat <<EOF
-AHE Codex skill installed.
-
-Next:
-1. Open Codex chat in this workspace.
-2. Use \`ahe init\` for a new start.
-3. Use exact \`ahe\` to continue existing harness work.
-EOF
-}
-
-doctor() {
-  local target_skills_dir="${PWD}/.codex/skills"
-  local target_shared_dir="${PWD}/.codex/ahe-shared"
-  local target_hooks_dir="${PWD}/.codex/hooks"
-  local skill_name=""
-
-  for skill_name in "${MANAGED_SKILLS[@]}"; do
-    if [ ! -f "${target_skills_dir}/${skill_name}/SKILL.md" ]; then
-      printf 'Missing: %s/%s/SKILL.md\n' "${target_skills_dir}" "${skill_name}" >&2
-      exit 1
-    fi
-  done
-
-  if [ ! -f "${target_shared_dir}/config.yaml" ]; then
-    printf 'Missing: %s/config.yaml\n' "${target_shared_dir}" >&2
-    exit 1
-  fi
-
-  if [ ! -d "${target_shared_dir}/templates" ]; then
-    printf 'Missing: %s/templates\n' "${target_shared_dir}" >&2
-    exit 1
-  fi
-
-  if [ ! -d "${target_shared_dir}/schemas" ]; then
-    printf 'Missing: %s/schemas\n' "${target_shared_dir}" >&2
-    exit 1
-  fi
-
-  if [ ! -f "${target_hooks_dir}/hooks.json" ]; then
-    printf 'Missing: %s/hooks.json\n' "${target_hooks_dir}" >&2
-    exit 1
-  fi
-
-  printf 'AHE skill installation looks healthy.\n'
-}
-
-uninstall_skill() {
-  local target_skills_dir="${PWD}/.codex/skills"
-  local target_shared_dir="${PWD}/.codex/ahe-shared"
-  local target_hooks_dir="${PWD}/.codex/hooks"
-  local target_config_path="${PWD}/.codex/config.toml"
-  local skill_name=""
-
-  echo "Uninstalling AHE skills from ${PWD}/.codex..."
-
-  for skill_name in "${MANAGED_SKILLS[@]}"; do
-    rm -rf "${target_skills_dir}/${skill_name}"
-  done
-
-  rm -rf "${target_shared_dir}"
-  rm -rf "${target_hooks_dir}"
-  cleanup_ahe_config_entries "${target_config_path}"
-
-  echo "AHE skills uninstalled successfully."
 }
 
 main() {
@@ -266,21 +72,18 @@ main() {
   fi
 
   local command="$1"
-  shift
-
+  
   case "${command}" in
-    install)
-      install_skill "$@"
-      ;;
-    uninstall)
-      uninstall_skill
-      ;;
-    doctor)
-      doctor
+    install|uninstall|doctor)
+      dispatch "$@"
       ;;
     version)
       printf '%s\n' "${VERSION}"
       ;;
+    -h|--help|help)
+      usage
+      exit 0
+      ;;
     *)
       printf 'Unknown command: %s\n' "${command}" >&2
       usage >&2

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@ksuchoi216/ahe",
-  "version": "0.1.6",
+  "version": "0.1.10",
   "description": "Codex chat workflow skill installer for Awesome Harness Engineering",
   "publishConfig": {
     "access": "public"
   },
+  "workspaces": [
+    "packages/*"
+  ],
   "bin": {
     "ahe": "./bin/ahe"
   },
   "scripts": {
     "test": "pytest tests/ -x",
-    "prepublishOnly": "npm run test"
+    "prepublishOnly": "npm run test",
+    "postinstall": "echo \"\" && echo \"Awesome Harness Engineering CLI installed!\" && echo \"To install the skills, run: ahe install\" && echo \"\" && echo \"If you wish to uninstall later, run: npm uninstall -g @ksuchoi216/ahe\""
   },
   "repository": {
     "type": "git",
@@ -27,7 +31,7 @@
   "author": "ksuchoi216",
   "files": [
     "bin/",
-    ".codex/"
+    "packages/"
   ],
   "license": "MIT"
-}
+}