@mthanhlm/autodev 0.4.4 → 0.5.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "autodev",
-  "description": "A lean Claude Code workflow system with a single entrypoint, task-based phase execution, and read-only git.",
-  "version": "0.4.4",
+  "description": "A global Claude Code plugin with durable repo context, hard verification gates, and read-only git.",
+  "version": "0.5.0",
   "author": {
     "name": "mthanhlm"
   },

package/PUBLISH.md

@@ -1,24 +1,8 @@
 # Publishing `@mthanhlm/autodev`
 
-## One-Time Setup
-
-1. Make sure the npm account `mthanhlm` has access to the `@mthanhlm` scope.
-2. Log in:
-
-```bash
-npm login
-```
-
-3. Verify the active account:
-
-```bash
-npm whoami
-```
-
 ## Pre-Publish Checklist
 
 ```bash
-cd autodev
 npm test
 claude plugin validate .
 npm pack
@@ -30,30 +14,21 @@ Check the tarball contents:
 tar -tf mthanhlm-autodev-$(node -p "require('./package.json').version").tgz
 ```
 
-## First Public Publish
+## Publish
 
-Scoped packages are private by default. The first public release must include `--access public`.
+First public release:
 
 ```bash
 npm publish --access public
 ```
 
-## Later Releases
-
-1. Bump the version in both `package.json` and `.claude-plugin/plugin.json`.
-2. Regenerate the tarball:
-
-```bash
-npm pack
-```
-
-3. Publish:
+Later releases:
 
 ```bash
 npm publish
 ```
 
-## Post-Publish Smoke Check
+## Smoke Check
 
 Verify npm sees the release:
 
@@ -61,22 +36,16 @@ Verify npm sees the release:
 npm view @mthanhlm/autodev version
 ```
 
-Then install from npm in a scratch directory:
+Install into a scratch Claude config directory:
 
 ```bash
 mkdir -p /tmp/autodev-smoke
-cd /tmp/autodev-smoke
-npx @mthanhlm/autodev@latest --local
+CLAUDE_CONFIG_DIR=/tmp/autodev-smoke npx @mthanhlm/autodev@latest
 ```
 
-Open Claude Code in that directory and run:
+Open Claude Code against any repo and run:
 
 ```text
-/autodev-help
-```
-
-Optional source-tree check during development:
-
-```bash
-claude --plugin-dir . agents
+/autodev
+/autodev-status
 ```

package/README.md

@@ -1,142 +1,108 @@
 # autodev
 
-`autodev` is a Claude Code workflow package built for one thing: get from idea to shipped code without the slow, over-engineered, git-writing behavior that made GSD painful.
-
-## What It Does
-
-- Installs a standalone Claude Code workflow under `~/.claude/` or `./.claude/`
-- Keeps project state in `.autodev/`
-- Uses `/autodev` as the main command
-- Adds `/autodev-auto` as the explicit opt-in continuous mode
-- Organizes work as `project -> track -> phase -> tasks`
-- Starts new projects and new tracks with a short discovery pass so requirements are based on the user's actual goal
-- Resolves `.autodev/` state from the repo root even when Claude is started in a nested subdirectory
-- Maps brownfield repos in the main session, with optional specialized helpers when the environment supports them
-- Runs a multi-lens review pass, using foreground review agents when the environment supports them
-- Can auto-format edited code after Claude writes files when a local formatter is available
-- Ships manual commands when you want direct control:
-  - `/autodev-auto`
-  - `/autodev-help`
-  - `/autodev-new-project`
-  - `/autodev-explore-codebase`
-  - `/autodev-plan-phase`
-  - `/autodev-execute-phase`
-  - `/autodev-review-task`
-  - `/autodev-review-phase`
-  - `/autodev-verify-work`
-  - `/autodev-cleanup`
-  - `/autodev-progress`
-- Treats git as read-only inside the workflow
+`autodev` is a global Claude Code plugin for one job: keep durable context in the repo, execute one bounded slice of work at a time, and stay honest about verification.
 
-## Install
+This reset removes the old workflow tree, multi-agent prompt theater, and markdown state machine. The new design is smaller on purpose.
 
-Primary supported usage is the standalone `npx` installer.
-The repo also carries Claude Code plugin metadata for validation and local development, but the supported end-user runtime remains the installed `.claude/` workflow.
-Supported runtime is Claude Code with Node plus `sh`/`bash` available.
+## Core Behavior
 
-```bash
-npx @mthanhlm/autodev@latest --global
-```
+- Installs globally into `~/.claude`
+- Forces `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1` in Claude Code `settings.json`
+- Uses `/autodev` as the main entrypoint
+- Uses `/autodev-status` for a compact state view
+- Keeps durable project context in `.autodev/`
+- Blocks git write commands while allowing read-only git
+- Auto-formats edited code when the repo already has a local formatter
+- Stops when verification is missing instead of pretending the work is done
 
-Interactive install with location selection:
+## Durable Files
 
-```bash
-npx @mthanhlm/autodev@latest
-```
+`autodev` keeps a small, inspectable file set in the repo:
+
+- `.autodev/state.json`
+  Machine state. This is the only authoritative state file.
+- `.autodev/brief.md`
+  Goal, constraints, users, and definition of done.
+- `.autodev/context.md`
+  Optional brownfield snapshot for the current goal.
+- `.autodev/plan.md`
+  One active plan with 3-7 items.
+- `.autodev/runs/*.md`
+  Append-only run reports with observed facts and verification results.
+
+## Install
 
-Local install for one repo:
+Supported mode is global install only.
 
 ```bash
-npx @mthanhlm/autodev@latest --local
+npx @mthanhlm/autodev@latest
 ```
 
-Install and also disable Claude Code background tasks in the target `settings.json`:
+Equivalent explicit form:
 
 ```bash
-npx @mthanhlm/autodev@latest --global --disable-background-tasks
+npx @mthanhlm/autodev@latest --global
 ```
 
 Uninstall:
 
 ```bash
-npx @mthanhlm/autodev@latest --global --uninstall
-npx @mthanhlm/autodev@latest --local --uninstall
+npx @mthanhlm/autodev@latest --uninstall
 ```
 
-## Default Flow
-
-Checkpointed:
+## Commands
 
 ```text
 /autodev
+/autodev-status
 ```
 
-Continuous until blocked or done:
-
-```text
-/autodev-auto
-```
-
-Typical brownfield route:
+Typical brownfield flow:
 
 ```text
 /autodev
-  -> new project
-  -> explore codebase
-  -> plan phase
-  -> review phase plan
-  -> execute one task
-  -> review task
-  -> execute one task
-  -> review task
-  -> review
-  -> verify
+  -> write brief.md
+  -> write context.md
+  -> write plan.md
+  -> execute one item
+  -> verify it
+  -> append a run report
+  -> stop or continue from state.json later
 ```
 
-## Workflow Model
-
-```text
-project -> track -> phase -> tasks
-```
+## Trust Rules
 
-- `project`
-  The repo or product context.
-- `track`
-  One initiative stream.
-- `phase`
-  One milestone-sized slice inside a track.
-- `task`
-  One reviewable implementation unit inside a phase.
-
-### Why Tasks Exist Under A Phase
-
-- Large phases are too big for one uninterrupted execution context
-- Developers need control over what changes next
-- Each task can run in a fresh foreground agent context
-- The main `/autodev` session stays small and orchestration-focused
-
-### Execution Model
-
-- `/autodev` remains the single entrypoint
-- `/autodev-auto` is the explicit continuous runner and never enables git writes
-- Project and track setup should clarify what the user wants to build, for whom, and what done looks like before writing state files
-- A phase is planned into one phase overview plus multiple task files
-- `/autodev` stops after planning so the user can review the phase before any execution starts
-- The phase keeps one user-facing orchestration session
-- Each task is preferably executed by a fresh foreground delegated agent
-- After each task, the delegated agent reports back with files changed, verification, and blockers
-- `/autodev` stops after each completed task and reopens a task review checkpoint before any further execution
-- `/autodev-auto` keeps going until the active track is done or a real stop condition appears, such as missing intent, dependency deadlock, or manual verification
-- If review or verification finds blockers, the same phase stays open and autodev should append remediation task(s) to that phase instead of replacing it or creating a follow-up phase by default
-- No waves by default
-- No automatic parallel execution
-- If specialized agents are unavailable in the current Claude Code environment, the workflow falls back cleanly to current-session execution instead of stopping on platform wording
-- If you want Claude Code itself to hard-disable background task functionality, install with `--disable-background-tasks`, which writes `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1` into Claude Code `settings.json`
-- The post-edit formatter hook uses only locally available tools such as `prettier`, `ruff`, `black`, `gofmt`, `rustfmt`, or `shfmt`, and skips `.autodev/` files
+- `state.json` is machine truth and is updated through the CLI, not by hand.
+- The plugin should not claim a task is done without observed verification output or explicit manual confirmation from the user.
+- If a check could not be run, the result is `Unverified`, not `Done`.
+- If the plan is blocked, update the remaining plan instead of expanding the system around the blockage.
 
 ## Git Policy
 
-`autodev` does not stage, commit, branch, merge, worktree, pull, push, or initialize git repositories. Read-only git commands like `git status`, `git diff`, and `git log` remain allowed.
+Blocked:
+
+- `git add`
+- `git commit`
+- `git checkout`
+- `git switch`
+- `git merge`
+- `git rebase`
+- `git push`
+- `git pull`
+- `git stash`
+- `git reset`
+- `git fetch`
+- `git clone`
+
+Allowed examples:
+
+- `git status`
+- `git diff`
+- `git log`
+- `git show`
+- `git rev-parse`
+- `git ls-files`
+- `git branch --show-current`
 
 ## Publish