duaer-spec 0.4.0 → 0.5.0

package/.cursor/rules/duaer-spec.mdc

@@ -1,28 +1,41 @@
 ---
-description: Prefer simple /duaer-do; Spec before code; handoff before claiming done
+description: Autonomous digital employee — run Duaer job loop without asking the user to operate
 alwaysApply: true
 ---
 
-# Duaer (keep it simple)
+# Digital employee (autonomous)
 
-Treat agents as digital employees. Prefer **one** everyday command:
+You are a **digital employee** in this repo. The human gives intent in normal
+language. **You** run the delivery process. Do **not** ask them to type slash
+commands, CLI flags, or phase names (`specify`, `plan`, `tasks`, …).
 
-`/duaer-do <ask>` → then `duaer status` if needed.
+If this conflicts with root `AGENTS.md` (worktrees, commits, Issue/PR),
+**AGENTS.md wins**.
 
-If this conflicts with `AGENTS.md` (worktrees, commits, Issue/PR), **AGENTS.md wins**.
+## When the human asks for work
 
-## Everyday
+For new behavior, fixes, refactors that change product behavior, or architecture:
 
-1. `/duaer-do` — assign Brief, implement, converge  
-2. Do **not** claim "done" unless the job is accepted (`duaer status`)  
-3. Do **not** make the user chain specify → plan → tasks → implement → converge for normal asks  
+1. **Silently follow** the procedure in `.cursor/skills/duaer-do/SKILL.md`
+   (assign Brief → light tasks → implement → converge → handoff line).
+2. Do **not** wait for `/duaer-do` or any other skill invocation.
+3. Do **not** say “please run `/duaer-specify`” — you do it.
+4. Do **not** dump a methodology tutorial unless they ask how Duaer works.
 
-## When to use step skills
+## Handoff
 
-- `/duaer-specify` only — reshape the Brief  
-- `/duaer-plan` / `/duaer-tasks` — large or architectural work  
-- `/duaer-implement` / `/duaer-converge` — resume mid-job  
+- End with whether the **job** is accepted or still open (one clear line).
+- Do **not** claim “done” / “finished” / “complete” unless `delivery.json` is
+  `accepted` and open tasks are clear.
+- Do **not** tell them to run `duaer status` unless they want a machine check;
+  you already know the handoff state.
 
-Hotfix: still a short Spec + accept (or `/duaer-do`).
+## Forbidden
 
-Forbidden: jump from chat to code with no Spec under `.duaer/specs/`.
+- Jump from chat to code with no Brief under `.duaer/specs/`.
+- Making the human operate the workflow.
+
+## Optional finer tools (agent-only)
+
+Step skills (`duaer-specify`, `duaer-plan`, …) are **your** playbooks when a
+job is large. The human should not need to know they exist.

package/.cursor/skills/duaer-do/SKILL.md

@@ -1,62 +1,57 @@
 ---
 name: "duaer-do"
-description: "Simple one-shot: turn a user ask into an assigned job, implement it, and hand off. Prefer this for everyday work instead of chaining specify/plan/tasks/implement/converge."
+description: "Autonomous job loop for digital employees: Brief → work → accept. Agents must follow this whenever the user asks for product work — without waiting for the user to invoke this skill or any CLI."
 compatibility: "Requires duaer-spec project structure with .duaer/ directory"
 metadata:
   author: "duaer-spec"
   source: "duaer-spec"
 ---
 
+## Trigger
+
+Any human ask that needs code or product behavior changed.  
+**Do not require** the human to type `/duaer-do` or name phases.
+
 ## User Input
 
 ```text
 $ARGUMENTS
 ```
 
-You **MUST** use the user input as the job request (if not empty).
+If empty, use the current conversation ask as the job.
 
 ## Goal
 
-**Everyday path — keep it simple.** Run one digital-employee job end-to-end without
-asking the user to chain slash commands.
+Run one job end-to-end. The human should only review the result.
 
-Do **not** lecture about methodology. Do the work.
+Do **not** lecture about methodology. Do **not** ask them to run commands.
 
-## Steps (always in order)
+## Steps (you perform these)
 
-1. **Assign** — Ensure an active feature Brief exists:
-   - If there is already a clear active job (`.duaer/active-job.json` + `spec.md`)
-     that matches this ask, update that `spec.md` acceptance as needed.
-   - Otherwise run the same outcome as `/duaer-specify` for this ask
-     (create `.duaer/specs/<nnn-slug>/spec.md`, write `.duaer/active-job.json`).
-   - For small asks: keep the Spec short (what / why / acceptance only).
+1. **Assign** — Ensure an active Brief:
+   - Matching active job (`.duaer/active-job.json` + `spec.md`) → update acceptance if needed.
+   - Else create `.duaer/specs/<nnn-slug>/spec.md` and `.duaer/active-job.json`
+     (same outcome as specify). Keep small asks short: what / why / acceptance.
 
-2. **Break down (lightweight)** — If `tasks.md` is missing:
-   - Write a short `tasks.md` with a few `- [ ]` items from the Spec.
-   - Skip `/duaer-plan` unless architecture or contracts clearly change.
-   - If `tasks.md` already exists, use it.
+2. **Break down** — If `tasks.md` missing, write a short checklist from the Spec.
+   Skip a heavy plan unless architecture or contracts change.
 
-3. **Work** — Implement open tasks (same rules as `/duaer-implement`).
-   Mark tasks `[x]` as you finish them. Do not expand scope past the Spec.
+3. **Work** — Implement open tasks; mark `[x]` as you go. No scope beyond Spec.
 
-4. **Accept** — Run the same outcome as `/duaer-converge`:
-   - Compare code to Spec; append gap tasks or stamp `delivery.json` accepted.
-   - If gaps were appended, either implement them now (preferred for small jobs)
-     or stop and tell the user what remains — once.
+4. **Accept** — Converge against Spec: stamp `delivery.json` `accepted`, or append
+   gap tasks and implement them when small enough; otherwise one clear remaining note.
 
-5. **Handoff line** — End with exactly one clear status:
-   - If accepted: `✅ Job accepted — ready for your review.`
-   - If not: `⏳ Job not accepted yet — <one sentence what to do next>.`
-   - Do **not** claim "done" unless `delivery.json` is `accepted` and tasks are clear
-     (coach/strict policy). Git is not locked.
+5. **Handoff** — One line to the human:
+   - `✅ Job accepted — ready for your review.`
+   - `⏳ Job not accepted yet — <one sentence>.`
+   Never claim done unless accepted + tasks clear. Git is not locked by this.
 
 ## Hotfix
 
-If the user says hotfix/bug/regression: still write a short Spec (symptom / cause /
-acceptance), then tasks → implement → converge. Same handoff line.
+Still a short Spec (symptom / cause / acceptance), then work + accept. Same handoff.
 
-## Out of scope for this command
+## Never
 
-- Do not require the user to run `/duaer-plan`, `/duaer-checklist`, or `/duaer-analyze`.
-- Do not discuss policy modes unless they ask.
-- Do not turn this into a merge/CI lecture.
+- Ask the human to run `/duaer-*`, `duaer status`, or `duaer policy`.
+- Discuss policy modes unless they ask.
+- Block on slash-command invocation.

package/.duaer/memory/constitution.md

@@ -10,14 +10,9 @@ Duaer for what to build.
 
 ### I. Spec before code (NON-NEGOTIABLE)
 
-Everyday: `/duaer-do` (assigns Spec, implements, converges).  
-Or the full chain. Never skip Spec or converge.
-
-Default path for fine control:
-
-`specify` → (optional plan/tasks) → `implement` → `converge` → `duaer status`
-
-Hotfix may shorten; still Spec + converge (or `/duaer-do`).
+The **agent** starts a Brief before coding — the human does not operate phases.
+Autonomous default: follow `duaer-do` (Brief → tasks → implement → converge).
+Never skip Spec or converge. Never ask the human to run `/duaer-*` for normal work.
 
 ### II. Read as-is before changing
 
@@ -37,6 +32,6 @@ Do not expand scope without updating the spec and tasks.
 Mark tasks complete only when the stated verification (tests, manual checks,
 or converge) has been performed or explicitly waived in the feature docs.
 
-**Job handoff (not a git lock):** prefer `duaer status`. Default policy is
-`coach` — do not claim "done" while the active job is unfinished. Users should
-not need to learn policy modes for everyday work.
+**Job handoff (not a git lock):** the agent reports accept/open itself.
+Default policy `coach` — do not claim "done" while the active job is unfinished.
+Do not send the human to run `duaer status` for routine work.

package/ADOPT.md

@@ -1,45 +1,42 @@
 # Adopt duaer-spec
 
-Install Duaer so agents act like digital employees with a simple everyday loop.
+Install once so the coding agent behaves as a **digital employee**: it runs
+Brief → work → accept **without** the human operating slash commands or CLI.
 
-## Install
+## Install (human, once)
 
 ```bash
 npx duaer-spec init --here
-# pin: npx github:fujiezee/duaer-spec@v0.4.0 duaer init --here
+# pin: npx github:fujiezee/duaer-spec@v0.5.0 duaer init --here
 ```
 
 ```bash
-npx duaer-spec init --here --method          # lite
+npx duaer-spec init --here --method
 npx duaer-spec init --here --ops --branch develop
 ```
 
-## Everyday use
+After that: talk to the agent in plain language. Do not teach them `/duaer-*`.
 
-1. `/duaer-do <ask>` in Cursor  
-2. `duaer status` when you want to see if the job is accepted  
+## What gets installed
 
-No need to learn policy modes or the full skill chain for normal work.
+- Always-on rule: agent must run the autonomous job loop on product work  
+- Playbook skill `duaer-do` (agent follows it; human need not invoke it)  
+- Optional step skills for large jobs (agent-only)  
+- Agent ops (`AGENTS.md`) when using `--all` / `--ops`
 
-## Finer control (optional)
+## Power users / agents
 
-| Command | When |
+| Tool | Who uses it |
 |---|---|
-| `/duaer-specify` | Only write / reshape the Brief |
-| `/duaer-plan` · `/duaer-tasks` | Large or architectural jobs |
-| `/duaer-implement` | Resume coding from `tasks.md` |
-| `/duaer-converge` | Re-check Spec vs code |
-| `duaer policy . strict` | Harder “don’t claim done” (still not a git lock) |
+| `/duaer-do` procedure | Agent (automatic) |
+| `/duaer-specify` … `/duaer-converge` | Agent, when splitting a large job |
+| `duaer status` / `duaer policy` | Optional diagnostics — not required of humans |
 
 ## Precedence
 
 1. `AGENTS.md` — how employees operate  
-2. `DUADER.md` / `.duaer/` — what to build  
+2. `DUADER.md` / `.duaer/` — how jobs are briefed  
 
 ## Updates
 
-`duaer init --force` (review the diff) or pin a tag. No auto-update.
-
-## Do not copy
-
-`examples/`, `SOURCE.md`, `bin/` / `package.json` (unless vendoring the CLI)
+`duaer init --force` (review the diff) or pin a tag.

package/AGENTS.md

@@ -3,8 +3,9 @@
 Mandatory rules for AI coding agents working in **duaer-spec**, and for any
 repository that adopts this file as its agent-ops contract.
 
-Treat agents as **digital employees**: this file is the workplace policy for
-*how* they may operate (isolation, commits, Issue/PR gates). Duaer
+Treat agents as **digital employees**: they execute the job loop themselves.
+Humans state intent; they do not operate Duaer phases. This file is workplace
+policy for *how* agents may operate (isolation, commits, Issue/PR gates). Duaer
 ([`DUADER.md`](DUADER.md)) is how jobs are briefed and accepted. If Duaer
 (`.duaer/`), `examples/`, or other overlays conflict with this file,
 **follow this file**.

package/CHANGELOG.md

@@ -1,39 +1,31 @@
 # Changelog
 
+## 0.5.0 — 2026-09-15
+
+### Autonomous digital employee
+
+- **Simplicity = humans do not operate the workflow**
+- Always-on rule: on product asks, the agent runs Brief → work → accept itself
+- Do not require `/duaer-do`, phase slash commands, or `duaer status` from humans
+- `duaer-do` is the agent’s internal playbook; install once, then talk
+- README / init / ADOPT / DUADER rewritten around “ask, don’t operate”
+
 ## 0.4.0 — 2026-09-15
 
 ### Simple everyday ops
 
-- **`/duaer-do`** — one Cursor skill for assign → work → accept
-- **`duaer status`** — plain “accepted / not done” (alias of `job`)
-- README / init / rules lead with hire → `/duaer-do` → `status`
-- Step skills and policy remain available but are advanced, not the default story
+- `/duaer-do` one-shot skill + `duaer status`
+- Step skills demoted to advanced (later reframed as agent-only in 0.5)
 
 ## 0.3.0 — 2026-09-15
 
 ### Job handoff (not a repo lock)
 
-- Default policy **`coach`**: guide the employee; do not claim "done" until the
-  **active job** is accepted — git merge is not blocked
-- `.duaer/delivery-policy.json` modes: `off` | `coach` | `strict`
-- `.duaer/active-job.json` set by `/duaer-specify`; `duaer job` reports status
-- `duaer policy` to show/set mode
-- `duaer check` defaults to active-job scope; `--strict` / policy `strict` optional
-- `--gate` kept as deprecated alias for `--strict` (job handoff, not CI)
-- `--all-jobs` optional; historical features no longer fail the default path
-- Docs/rules/constitution demote merge-gate language
-
-### E2E
-
-- E2E-004–007 for coach default, strict optional, active-job scope
+- `coach` / `strict` / `off` policy; active job; `duaer job` / `policy`
 
 ## 0.2.0 — 2026-09-15
 
-### Controllable delivery (machine gate)
-
-- `/duaer-converge` writes `.duaer/specs/<feature>/delivery.json`
-- `duaer check` / `--gate` for handoff state
-- Honest scope: handoff state checkable; Spec↔code still agent-assisted
+- `delivery.json` + checkable handoff state
 
 ## 0.1.1 — 2026-09-15
 

package/DUADER.md

@@ -1,54 +1,45 @@
 # Duaer methodology
 
-Treat AI coding agents as **digital employees**. Everyday path is short; the
-full chain exists when you need it.
+AI coding agents are **digital employees**. The human states intent; the agent
+runs Brief → work → accept. Humans are not the operators of the phase machine.
 
 **Precedence:** [`AGENTS.md`](AGENTS.md) wins on isolation, commits, Issue/PR.
 
-## Everyday (default)
+## Human experience
 
-```text
-/duaer-do <ask>     →  duaer status
-```
-
-`/duaer-do` assigns a Brief, implements, converges, and reports handoff.
-Do not require the user to run every phase skill.
+1. One-time: `npx duaer-spec init --here`  
+2. Ongoing: describe work in chat  
+3. Review the handoff line (accepted / not yet)
 
-## Full path (optional)
+## Agent procedure (autonomous)
 
-1. `/duaer-specify` — Brief  
-2. `/duaer-plan` — when architecture/contracts change  
-3. `/duaer-tasks` — explicit checkbox breakdown  
-4. `/duaer-implement` — code from tasks  
-5. `/duaer-converge` — accept stamp (`delivery.json`)  
-6. `duaer status` — may we claim this job done?
+Follow `.cursor/skills/duaer-do/SKILL.md` on every product ask — **without**
+waiting for a slash invocation:
 
-Hotfix: short Spec → tasks → implement → converge (or just `/duaer-do`).
+1. Assign Brief + `active-job.json`  
+2. Light `tasks.md` if needed  
+3. Implement  
+4. Converge → `delivery.json`  
+5. One handoff line; never claim done until accepted  
 
-Never skip a Brief or an accept step. Under default **coach** policy, do not
-claim "done" while `duaer status` is unfinished. This is **job handoff**, not a
-git merge lock.
+Large jobs may use step playbooks (`duaer-specify`, `duaer-plan`, …) internally.
 
-## Install
-
-```bash
-npx duaer-spec init --here
-```
+## Policy
 
-See [`ADOPT.md`](ADOPT.md).
+`.duaer/delivery-policy.json` defaults to `coach`. Agents must not claim done
+while the active job is unfinished. This is job etiquette, not a git lock.
+Humans need not configure it for everyday use.
 
 ## Layout
 
 ```text
-.duaer/delivery-policy.json   # default coach — usually ignore
-.duaer/active-job.json        # current job
-.duaer/specs/<nnn-slug>/
-  spec.md
-  tasks.md
-  delivery.json
+.duaer/active-job.json
+.duaer/specs/<nnn-slug>/spec.md|tasks.md|delivery.json
+.cursor/rules/duaer-spec.mdc      # autonomous behavior
+.cursor/skills/duaer-do/          # default job loop
 ```
 
 ## Related
 
+- Adopt: [`ADOPT.md`](ADOPT.md)
 - Agent ops: [`AGENTS.md`](AGENTS.md)
-- Maintainer notes: [`docs/maintaining.md`](docs/maintaining.md)

package/README.md

@@ -1,51 +1,37 @@
 # duaer-spec
 
-**Duaer** makes AI coding agents work like digital employees: assign a job,
-get a controllable handoff — without a rigid git lock.
+**Duaer** turns AI coding agents into **digital employees**: they take a normal
+language ask, run Spec → work → accept themselves, and only claim a job done
+when the handoff is clean.
 
-## Everyday (this is enough)
+You should **not** have to operate the workflow. After a one-time install, you
+talk; the employee runs the process.
 
-```bash
-npx duaer-spec init --here
-```
-
-In Cursor, one command:
-
-```text
-/duaer-do <what you want built or fixed>
-```
-
-See if the job can be reported done:
+## One-time install
 
 ```bash
-duaer status
+npx duaer-spec init --here
 ```
 
-That’s the whole loop: **hire → do → status**.
+Then use Cursor as usual — describe what you want. No slash-command chain
+required.
 
-## What `/duaer-do` does
+## What the employee does (by itself)
 
-1. Writes a short Brief (Spec)  
-2. Implements it  
-3. Checks against the Brief and stamps accept / still-open  
+1. Writes a Brief (Spec) for the ask  
+2. Implements within that Brief  
+3. Checks the result and stamps accept / still-open  
+4. Tells you in one line whether the job is ready for review  
 
-You do **not** need to chain specify → plan → tasks → implement → converge
-for normal work. Those remain available when you want finer control.
+Step skills and CLI checks exist for agents and power users — not as the
+everyday human UI.
 
 ## Optional
 
 ```bash
-duaer status          # active job: accepted or not
-npx duaer-spec@0.4.0 init --here --method   # method only
+npx duaer-spec@0.5.0 init --here --method   # method only
 ```
 
-Advanced (policy, full check, step-by-step skills): [`ADOPT.md`](ADOPT.md) · [`DUADER.md`](DUADER.md)
-
-## Two layers
-
-| Layer | Role |
-|---|---|
-| **Agent ops** | How agents may operate — [`AGENTS.md`](AGENTS.md) |
-| **Duaer method** | How jobs are briefed and accepted — [`.duaer/`](.duaer/), skills |
+Details: [`ADOPT.md`](ADOPT.md) · Method: [`DUADER.md`](DUADER.md) · Ops: [`AGENTS.md`](AGENTS.md)
 
-When they conflict, **agent ops win**.
+When agent ops and method conflict, **agent ops win**.

package/bin/duaer.mjs

@@ -26,23 +26,19 @@ const POLICY_MODES = new Set(['off', 'coach', 'strict'])
 
 const USAGE = `duaer — digital-employee delivery (duaer-spec ${PKG.version})
 
-Everyday:
-  duaer init [--here]     Hire into a project
-  duaer status [dir]      Is the active job accepted?
+Human (once):
+  duaer init [--here]     Install so the agent works as a digital employee
 
-In Cursor:  /duaer-do <what you want>
+After install: talk to the agent in plain language. Do not operate /duaer-* phases.
 
-Advanced:
-  duaer check [dir] [--workplace|--job|--all-jobs|--strict]
-  duaer job [dir]                    (same as status)
-  duaer policy [dir] [off|coach|strict]
-  duaer version
+Agent / optional diagnostics:
+  duaer status [dir]
+  duaer check | policy | version
 
 Init: --all (default) | --method | --ops | --force | --branch <n> | --here
 
-Examples:
+Example:
   npx duaer-spec init --here
-  duaer status
 `
 
 function parseArgs(argv) {
@@ -283,12 +279,12 @@ function cmdInit(opts) {
   }
 
   console.log(`
-Hired. Everyday loop:
+Hired.
 
-  1. In Cursor:  /duaer-do <what you want>
-  2. Optional:   duaer status
+You: describe work in Cursor (plain language).
+Agent: runs Brief → work → accept by itself — do not operate slash phases.
 
-That is enough for normal work. Advanced: ADOPT.md / DUADER.md
+Optional diagnostic: duaer status
 `)
 }
 

package/docs/agent/change-checklist.md

@@ -94,7 +94,7 @@ See [spec update guidance](workflow.md#3-spec-update-guidance).
 
 ## 6. Merge / PR
 
-- [ ] Active job handoff considered: `duaer job .` (coach/strict: do not claim done if unfinished).
+- [ ] Active job handoff considered by the **agent** (do not require the human to run CLI for routine work).
 - [ ] Branch refreshed against latest `main`.
 - [ ] Merged into local `main` (and/or remote PR/MR when required).
 - [ ] Only this request's logical changes included.

package/docs/agent/e2e-test-plan.md

@@ -25,26 +25,20 @@ the table for their app.
 
 | ID | Title | Status |
 |---|---|---|
-| E2E-001 | After `duaer init`, CLI prints simple `/duaer-do` next steps | manual |
-| E2E-002 | README everyday path is hire → `/duaer-do` → `status` | manual |
-| E2E-003 | `duaer status` shows accepted / not done in plain language | manual |
-| E2E-004 | Default `coach` policy: unfinished job warns but check exits 0 | manual |
-| E2E-005 | After converge stamps `accepted`, `duaer status` shows accepted | manual |
-| E2E-006 | `duaer policy . strict` then unfinished job makes check exit 1 | manual |
-| E2E-007 | `--all-jobs` is optional; default scope is active job only | manual |
-| E2E-008 | `/duaer-do` skill is installed by `duaer init` | manual |
+| E2E-001 | After `duaer init`, banner says talk to agent — no slash ops | manual |
+| E2E-002 | README: install once, then plain-language asks | manual |
+| E2E-003 | Always-on rule requires autonomous job loop without user slash | manual |
+| E2E-004 | Default `coach`: unfinished job — agent must not claim done | manual |
+| E2E-005 | Converge stamps `accepted`; agent reports ready for review | manual |
+| E2E-006 | `duaer-do` skill describes agent-triggered loop | manual |
 
 ## Traceability
 
-Keep this matrix current when scenarios or specs change.
-
 | Scenario | Spec / feature | Notes |
 |---|---|---|
-| E2E-001 | `bin/duaer.mjs` init banner | Simple onboarding |
-| E2E-002 | `README.md` | Everyday path |
-| E2E-003 | `duaer status` | Plain language |
-| E2E-004 | `delivery-policy.json` coach | Not a repo lock |
-| E2E-005 | converge → `delivery.json` | Accept stamp |
-| E2E-006 | policy strict | Optional |
-| E2E-007 | `--all-jobs` vs active | Scope |
-| E2E-008 | `.cursor/skills/duaer-do` | One-shot skill |
+| E2E-001 | init banner | No human phase ops |
+| E2E-002 | README | Ask, don’t operate |
+| E2E-003 | `duaer-spec.mdc` | Autonomous |
+| E2E-004 | policy coach | Handoff etiquette |
+| E2E-005 | `delivery.json` | Accept stamp |
+| E2E-006 | `duaer-do` | Internal playbook |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duaer-spec",
-  "version": "0.4.0",
-  "description": "Simple digital-employee delivery: /duaer-do + duaer status",
+  "version": "0.5.0",
+  "description": "Digital employees that run Spec→work→accept themselves — humans just ask",
   "type": "module",
   "bin": {
     "duaer": "bin/duaer.mjs",