duaer-spec 0.2.0 → 0.4.0

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

@@ -1,35 +1,28 @@
 ---
-description: Features and hotfixes must go through Duaer; no code from verbal asks alone
+description: Prefer simple /duaer-do; Spec before code; handoff before claiming done
 alwaysApply: true
 ---
 
-# Duaer required (NON-NEGOTIABLE)
+# Duaer (keep it simple)
 
-Treat agents as digital employees: assign a Brief (Spec) before code; accept
-only via converge. See `DUADER.md` and `.duaer/memory/constitution.md`.
+Treat agents as digital employees. Prefer **one** everyday command:
 
-If this rule conflicts with root `AGENTS.md` / `docs/agent/` (worktrees, commits,
-Issue/PR), **AGENTS.md wins**.
+`/duaer-do <ask>` → then `duaer status` if needed.
 
-## When Duaer is mandatory
+If this conflicts with `AGENTS.md` (worktrees, commits, Issue/PR), **AGENTS.md wins**.
 
-Always write/update a feature spec (Brief) before coding for:
+## Everyday
 
-- New features / user-visible behavior
-- Architecture or contract changes
-- Hotfixes / regressions (still Spec; shorter path allowed)
+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  
 
-Forbidden: jump from chat to code with no `spec.md` / feature directory under `.duaer/specs/`.
+## When to use step skills
 
-## Default flow
+- `/duaer-specify` only — reshape the Brief  
+- `/duaer-plan` / `/duaer-tasks` — large or architectural work  
+- `/duaer-implement` / `/duaer-converge` — resume mid-job  
 
-`/duaer-specify` → `/duaer-plan` → `/duaer-tasks` → `/duaer-implement` → `/duaer-converge`
+Hotfix: still a short Spec + accept (or `/duaer-do`).
 
-## Hotfix (still Spec, shortened)
-
-`/duaer-specify` (mark hotfix: symptom / root cause / acceptance) → `/duaer-tasks` → `/duaer-implement` → `/duaer-converge`
-
-- Implement only from `tasks.md` when it exists
-- Update `.duaer/memory/project-context.md` when architecture changes
-- Run the verification named in the feature docs before merge
-- Before merge: `duaer check . --gate` (Spec present, no open tasks, `delivery.json` accepted)
+Forbidden: jump from chat to code with no Spec under `.duaer/specs/`.

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

@@ -265,15 +265,18 @@ Append to the **end** of `tasks.md`, per the append contract:
   path instead — do not stamp accepted).
 - Report: **"✅ Converged — the implementation satisfies the spec, plan, and tasks."**
 - Include the summary counts of what was checked.
-- Tell the user they can run `duaer check . --gate` to verify the machine gate.
+- Tell the user they can run `duaer job .` to see handoff status (policy default: coach).
+- Reminder: this is **job acceptance**, not a repository merge lock.
 ### 8. Provide Next Actions (Handoff)
 
 - On `tasks_appended`: state how many tasks were appended under which phase, and recommend
   running `/duaer-implement` to complete them; note that a follow-up converge
   run will find fewer or no remaining items. Remind: `delivery.json` is `open` —
-  `duaer check --gate` will fail until accepted.
-- On `converged`: recommend `duaer check . --gate`, then review / opening a PR. No further
-  implement pass is needed for this feature's specified scope.
+  under coach/strict, do **not** claim the job is done; `duaer job .` will show unfinished.
+- On `converged`: recommend `duaer job .`, then ask the user to review. No further
+  implement pass is needed for this feature's specified scope. Use the handoff script:
+  "✅ Job accepted — Brief satisfied per converge; ready for your review."
+  Do not frame this as a git/CI merge requirement.
 
 ### 9. Check for extension hooks
 

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

@@ -0,0 +1,62 @@
+---
+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."
+compatibility: "Requires duaer-spec project structure with .duaer/ directory"
+metadata:
+  author: "duaer-spec"
+  source: "duaer-spec"
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** use the user input as the job request (if not empty).
+
+## Goal
+
+**Everyday path — keep it simple.** Run one digital-employee job end-to-end without
+asking the user to chain slash commands.
+
+Do **not** lecture about methodology. Do the work.
+
+## Steps (always in order)
+
+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).
+
+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.
+
+3. **Work** — Implement open tasks (same rules as `/duaer-implement`).
+   Mark tasks `[x]` as you finish them. Do not expand scope past the 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.
+
+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.
+
+## Hotfix
+
+If the user says hotfix/bug/regression: still write a short Spec (symptom / cause /
+acceptance), then tasks → implement → converge. Same handoff line.
+
+## Out of scope for this command
+
+- 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.

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

@@ -104,11 +104,23 @@ Given that feature description, do this:
      Write the actual resolved directory path value (for example, `specs/003-user-auth`), not the literal string `SPECIFY_FEATURE_DIRECTORY`.
      This allows downstream commands (`/duaer-plan`, `/duaer-tasks`, etc.) to locate the feature directory without relying on git branch name conventions.
 
+   - Also write / overwrite `.duaer/active-job.json` (job handoff pointer):
+     ```json
+     {
+       "schemaVersion": 1,
+       "feature": "<directory-name only, e.g. 003-user-auth>",
+       "featureDirectory": "<resolved feature dir>",
+       "updatedAt": "<ISO-8601 UTC>",
+       "source": "duaer-specify"
+     }
+     ```
+     `feature` is the basename under `.duaer/specs/` (or `specs/`) that `duaer job` resolves.
+
    **IMPORTANT**:
    - You must only create one feature per `/duaer-specify` invocation
    - The spec directory name and the git branch name are independent — they may be the same but that is the user's choice
    - The spec directory and file are always created by this command, never by the hook
-
+   - Setting `active-job.json` makes this the job the employee must hand off; it does **not** lock git
 4. Load the resolved active `spec-template` file to understand required sections.
 
 5. **IF EXISTS**: Load `.duaer/memory/constitution.md` for project principles and governance constraints.

package/.duaer/delivery-policy.json

@@ -0,0 +1,6 @@
+{
+  "schemaVersion": 1,
+  "mode": "coach",
+  "scope": "active",
+  "notes": "Job-level handoff. off=record only; coach=guide (default); strict=do not claim done until accepted. Not a git merge lock."
+}

package/.duaer/memory/constitution.md

@@ -10,13 +10,14 @@ Duaer for what to build.
 
 ### I. Spec before code (NON-NEGOTIABLE)
 
-Features, architecture changes, and hotfixes start with a Duaer feature
-artifact before implementation. Default path:
+Everyday: `/duaer-do` (assigns Spec, implements, converges).  
+Or the full chain. Never skip Spec or converge.
 
-`constitution` → `specify` → (optional `clarify`) → `plan` → (optional `checklist` / `analyze`) → `tasks` → `implement` → `converge`
+Default path for fine control:
 
-Hotfix may shorten to: `specify` (mark hotfix) → `tasks` → `implement` → `converge`.
-Never skip `specify` or `converge`.
+`specify` → (optional plan/tasks) → `implement` → `converge` → `duaer status`
+
+Hotfix may shorten; still Spec + converge (or `/duaer-do`).
 
 ### II. Read as-is before changing
 
@@ -36,7 +37,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.
 
-Before merge, run `duaer check . --gate`. It fails on missing Spec, open
-`- [ ]` tasks, or `delivery.json` that is not `status: "accepted"`. Converge
-assessment is still agent-assisted; the gate makes the **handoff state**
-machine-checkable.
+**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.

package/ADOPT.md

@@ -1,77 +1,45 @@
 # Adopt duaer-spec
 
-Onboard a **digital employee** into another repository: install the Duaer
-delivery OS (method) and the agent-ops contract (how they are allowed to work).
+Install Duaer so agents act like digital employees with a simple everyday loop.
 
-## Recommended: CLI
-
-From the target project (Node 18+):
+## Install
 
 ```bash
 npx duaer-spec init --here
-
-# Pin a release
-npx github:fujiezee/duaer-spec@v0.2.0 duaer init --here
-
-# Lite (method only) / ops only / other integration branch
-npx duaer-spec init --here --method
-npx duaer-spec init --here --ops --branch develop
+# pin: npx github:fujiezee/duaer-spec@v0.4.0 duaer init --here
 ```
 
-From a clone of this repo:
-
 ```bash
-node bin/duaer.mjs init /path/to/project --all
-node bin/duaer.mjs check /path/to/project
+npx duaer-spec init --here --method          # lite
+npx duaer-spec init --here --ops --branch develop
 ```
 
-`--force` overwrites managed files.
-
-Then:
+## Everyday use
 
-1. **Orient** — edit `.duaer/memory/constitution.md` and `project-context.md`
-2. **Confirm workplace** — `docs/baseline.md` (integration branch)
-3. **Assign → work → accept → gate** — `/duaer-specify` → `/duaer-plan` → `/duaer-tasks` → `/duaer-implement` → `/duaer-converge` → `duaer check . --gate`
+1. `/duaer-do <ask>` in Cursor  
+2. `duaer status` when you want to see if the job is accepted  
 
-A job without Spec is not assigned. Open tasks or a non-`accepted` `delivery.json`
-is not accepted. `duaer check --gate` is the machine merge check.
+No need to learn policy modes or the full skill chain for normal work.
 
-## Manual copy (optional)
+## Finer control (optional)
 
-### Agent ops
-
-```bash
-cp AGENTS.md /path/to/project/
-mkdir -p /path/to/project/.cursor/rules /path/to/project/docs/agent
-cp .cursor/rules/agents-workflow.mdc /path/to/project/.cursor/rules/
-cp .cursor/rules/ai-ui-copy.mdc /path/to/project/.cursor/rules/
-cp docs/agent/workflow.md docs/agent/change-checklist.md docs/agent/e2e-test-plan.md \
-  /path/to/project/docs/agent/
-```
-
-### Duaer method
-
-```bash
-rsync -a .duaer/ /path/to/project/.duaer/
-mkdir -p /path/to/project/.cursor/skills /path/to/project/.cursor/rules
-rsync -a .cursor/skills/ /path/to/project/.cursor/skills/
-cp .cursor/rules/duaer-spec.mdc /path/to/project/.cursor/rules/
-cp DUADER.md /path/to/project/
-```
+| Command | When |
+|---|---|
+| `/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) |
 
 ## Precedence
 
-1. `AGENTS.md` / agent-ops — how employees operate  
+1. `AGENTS.md` — how employees operate  
 2. `DUADER.md` / `.duaer/` — what to build  
-3. Product overlays (do not copy `examples/` blindly)
 
 ## Updates
 
-Re-run `duaer init --force` (review the diff) or pin to a commit/tag. Adopters
-are not auto-updated.
+`duaer init --force` (review the diff) or pin a tag. No auto-update.
 
 ## Do not copy
 
-- `examples/` — samples only
-- `SOURCE.md` — provenance for maintainers
-- `bin/` / `package.json` — only needed if you vendor the CLI itself
+`examples/`, `SOURCE.md`, `bin/` / `package.json` (unless vendoring the CLI)

package/CHANGELOG.md

@@ -1,54 +1,44 @@
 # Changelog
 
-## 0.2.0 — 2026-09-15
+## 0.4.0 — 2026-09-15
 
-### Controllable delivery (machine gate)
+### Simple everyday ops
 
-- `/duaer-converge` writes `.duaer/specs/<feature>/delivery.json`
-  (`accepted` | `open`)
-- `duaer check` reports workplace **and** delivery status
-- `duaer check --gate` fails on missing Spec, open tasks, or non-accepted stamp
-- Constitution, DUADER, README, ADOPT, and merge checklist require the gate
-- Honest scope: gate checks **handoff state**; Spec↔code judgment remains
-  agent-assisted
+- **`/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
 
-### E2E
-
-- E2E-003 / E2E-004 / E2E-005 for delivery report and gate
-
-## 0.1.1 — 2026-09-15
+## 0.3.0 — 2026-09-15
 
-### Docs / product identity
+### Job handoff (not a repo lock)
 
-- Position Duaer as a **delivery OS for AI digital employees**: hire → assign
-  (Spec) → work → accept (converge)
-- README, ADOPT, DUADER, AGENTS intro, and CLI `init` / `check` / help copy
-  use that language
-- E2E catalog: E2E-001 (init next steps), E2E-002 (README positioning)
+- 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
 
-## 0.1.0 — 2026-09-15
+### E2E
 
-First public methodology release.
+- E2E-004–007 for coach default, strict optional, active-job scope
 
-### Method
+## 0.2.0 — 2026-09-15
 
-- Own **Duaer** Spec-Driven loop: specify → plan → tasks → implement → converge
-- Home directory: `.duaer/` (not an embedded third-party kit)
-- Cursor skills: `/duaer-specify`, `/duaer-plan`, `/duaer-tasks`, `/duaer-implement`, `/duaer-converge`, …
-- Agent ops (`AGENTS.md`) remain authoritative over the method when they conflict
+### Controllable delivery (machine gate)
 
-### CLI
+- `/duaer-converge` writes `.duaer/specs/<feature>/delivery.json`
+- `duaer check` / `--gate` for handoff state
+- Honest scope: handoff state checkable; Spec↔code still agent-assisted
 
-- `duaer init [dir] --all|--method|--ops [--force] [--branch <name>]`
-- `duaer check [dir]`
-- `duaer version`
+## 0.1.1 — 2026-09-15
 
-### Install
+- Digital-employee delivery OS positioning
 
-```bash
-# From GitHub (works now)
-npx github:fujiezee/duaer-spec@v0.1.0 duaer init --here
+## 0.1.0 — 2026-09-15
 
-# From npm (after publish)
-npx duaer-spec init --here
-```
+- First public methodology release

package/DUADER.md

@@ -1,40 +1,33 @@
 # Duaer methodology
 
-**duaer-spec** owns this method. Treat AI coding agents as **digital employees**:
-you assign a Brief (Spec), they follow a fixed work order, and delivery only
-counts after **converge** accepts the result against that Brief.
+Treat AI coding agents as **digital employees**. Everyday path is short; the
+full chain exists when you need it.
 
-Artifacts live under `.duaer/`; Cursor skills are `duaer-*` at `.cursor/skills/`.
+**Precedence:** [`AGENTS.md`](AGENTS.md) wins on isolation, commits, Issue/PR.
 
-**Precedence:** root [`AGENTS.md`](AGENTS.md) / [`docs/agent/`](docs/agent/) win
-over anything here for isolation, commits, and Issue/PR gates.
+## Everyday (default)
 
-## Read before work
-
-1. `.duaer/memory/constitution.md` — process principles
-2. `.duaer/memory/project-context.md` — as-is implementation truth
-3. `.duaer/memory/testing.md` — verification expectations
-4. Active feature under `.duaer/specs/<nnn-slug>/` when one exists
+```text
+/duaer-do <ask>     →  duaer status
+```
 
-## Standard path
+`/duaer-do` assigns a Brief, implements, converges, and reports handoff.
+Do not require the user to run every phase skill.
 
-**Full (recommended):**
+## Full path (optional)
 
-1. `/duaer-constitution` — only when principles change
-2. `/duaer-specify` — **Assign**: what / why / acceptance (not stack trivia)
-3. `/duaer-clarify` — optional
-4. `/duaer-plan` — technical plan aligned with project-context
-5. `/duaer-checklist` — optional quality checklist
-6. `/duaer-tasks` — checkbox task breakdown
-7. `/duaer-analyze` — optional consistency check
-8. `/duaer-implement` — implement tasks only
-9. `/duaer-converge` — **Accept**: compare result to Spec; write `delivery.json`; append remaining tasks if gaps
-10. `duaer check . --gate` — **Gate**: fail merge if Spec missing, tasks open, or stamp not accepted
+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?
 
-**Small feature:** specify → plan → tasks → implement → converge → `check --gate`  
+Hotfix: short Spec → tasks → implement → converge (or just `/duaer-do`).
 
-**Hotfix:** specify (mark hotfix) → tasks → implement → converge → `check --gate`  
-Never skip specify (assign), converge (accept), or the gate.
+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.
 
 ## Install
 
@@ -42,18 +35,17 @@ Never skip specify (assign), converge (accept), or the gate.
 npx duaer-spec init --here
 ```
 
-Or see [`ADOPT.md`](ADOPT.md). No third-party Spec CLI is required — `duaer`
-installs this repository's method files into the target project.
+See [`ADOPT.md`](ADOPT.md).
 
-## Feature directory shape
+## Layout
 
 ```text
+.duaer/delivery-policy.json   # default coach — usually ignore
+.duaer/active-job.json        # current job
 .duaer/specs/<nnn-slug>/
-  spec.md         # Brief
-  plan.md         # after /duaer-plan
-  tasks.md        # after /duaer-tasks
-  delivery.json   # after /duaer-converge (accepted | open)
-  …               # research / contracts as needed
+  spec.md
+  tasks.md
+  delivery.json
 ```
 
 ## Related

package/README.md

@@ -1,102 +1,51 @@
 # duaer-spec
 
-**Duaer** is a delivery operating system for AI coding agents treated as
-**digital employees**.
+**Duaer** makes AI coding agents work like digital employees: assign a job,
+get a controllable handoff — without a rigid git lock.
 
-Agents write the code. Duaer makes the **handoff controllable**: every job has a
-Brief (Spec), follows a fixed work order, and only counts as done when the
-**delivery gate** passes — not after a lucky chat.
-
-Cursor is the labor. Duaer is hire → assign → accept.
-
-## Install (onboard the employee)
+## Everyday (this is enough)
 
 ```bash
 npx duaer-spec init --here
-# or pin: npx github:fujiezee/duaer-spec@v0.2.0 duaer init --here
 ```
 
-```bash
-# Lite: method only (personal / small changes)
-npx duaer-spec init --here --method
+In Cursor, one command:
 
-# Full ops on another integration branch
-npx duaer-spec init --here --ops --branch develop
+```text
+/duaer-do <what you want built or fixed>
 ```
 
-Verify: `npx duaer-spec check .`  
-Merge gate: `npx duaer-spec check . --gate`  
-Details: [`ADOPT.md`](ADOPT.md)
-
-## How you run them
-
-| Step | Meaning | Command |
-|---|---|---|
-| **Hire** | Install SOP + gates into the repo | `duaer init` |
-| **Assign** | Write the Brief (what / why / acceptance) | `/duaer-specify` |
-| **Work** | Plan, break down, implement | `/duaer-plan` → `/duaer-tasks` → `/duaer-implement` |
-| **Accept** | Converge stamps `delivery.json`; gaps stay open | `/duaer-converge` |
-| **Gate** | Machine check before merge | `duaer check . --gate` |
-
-Never skip **Assign** or **Accept**. Hotfix may shorten the middle; Spec,
-converge, and the gate stay.
-
-### What the gate actually enforces
-
-`duaer check --gate` fails when any feature under `.duaer/specs/` has:
-
-- missing `spec.md`
-- open `- [ ]` tasks in `tasks.md`
-- missing `delivery.json`, or `status` other than `accepted`
-
-Converge judgment is still agent-assisted. The gate makes **handoff state**
-checkable (and CI-friendly), not a substitute for tests.
+See if the job can be reported done:
 
-## Two layers
-
-| Layer | Role | Where |
-|---|---|---|
-| **Agent ops** | How the employee is allowed to operate | [`AGENTS.md`](AGENTS.md), [`docs/agent/`](docs/agent/) |
-| **Duaer method** | What to build (Spec → Plan → Tasks → Implement → Converge) | [`DUADER.md`](DUADER.md), [`.duaer/`](.duaer/), [`.cursor/skills/`](.cursor/skills/) |
-
-When they conflict, **agent ops win** — process beats improvisation.
+```bash
+duaer status
+```
 
-## Default loop
+That’s the whole loop: **hire → do → status**.
 
-```text
-constitution → specify → plan → tasks → implement → converge → check --gate
-```
+## What `/duaer-do` does
 
-Small change: `specify → plan → tasks → implement → converge`  
-Hotfix: `specify (hotfix) → tasks → implement → converge`
+1. Writes a short Brief (Spec)  
+2. Implements it  
+3. Checks against the Brief and stamps accept / still-open  
 
-Slash skills: `/duaer-specify`, `/duaer-plan`, `/duaer-tasks`, `/duaer-implement`,
-`/duaer-converge`, …
+You do **not** need to chain specify → plan → tasks → implement → converge
+for normal work. Those remain available when you want finer control.
 
-## Layout
+## Optional
 
-```text
-bin/duaer.mjs             CLI (duaer init | check | version)
-package.json              npm package metadata
-AGENTS.md                 Agent-ops contract (how employees operate)
-DUADER.md                 Methodology conventions (how work is briefed)
-ADOPT.md                  Onboarding guide
-.duaer/                   Memory, templates, workflows, scripts
-.duaer/specs/<feature>/   Brief + tasks + delivery.json stamp
-.cursor/rules/            Agent-ops + Duaer rules
-.cursor/skills/           duaer-* skills
-docs/agent/               Workflow detail + checklists
-docs/maintaining.md       How maintainers evolve the method
-docs/npm-trusted-publishing.md  npm Trusted Publishing (OIDC) setup
-examples/                 Optional product overlays (not defaults)
+```bash
+duaer status          # active job: accepted or not
+npx duaer-spec@0.4.0 init --here --method   # method only
 ```
 
-## Defaults (this repo)
+Advanced (policy, full check, step-by-step skills): [`ADOPT.md`](ADOPT.md) · [`DUADER.md`](DUADER.md)
 
-- Integration branch: **`main`**
-- One request → one branch + one worktree → merge → delete worktree
-- Push only when explicitly requested
+## Two layers
 
-## Learn more
+| Layer | Role |
+|---|---|
+| **Agent ops** | How agents may operate — [`AGENTS.md`](AGENTS.md) |
+| **Duaer method** | How jobs are briefed and accepted — [`.duaer/`](.duaer/), skills |
 
-Method: [`DUADER.md`](DUADER.md) · Agent ops: [`AGENTS.md`](AGENTS.md)
+When they conflict, **agent ops win**.

package/bin/duaer.mjs

@@ -2,10 +2,8 @@
 /**
  * duaer — CLI for the duaer-spec delivery OS (digital employees)
  *
- *   duaer init [dir] [--all|--method|--ops] [--force] [--branch <name>]
- *   duaer check [dir] [--workplace|--delivery|--gate]
- *   duaer version
- *   duaer help
+ * Everyday:  duaer init | duaer status
+ * Advanced:  check | job | policy | version
  */
 
 import {
@@ -24,35 +22,27 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 const PKG_ROOT = resolve(__dirname, '..')
 const PKG = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8'))
 
-const USAGE = `duaer — Delivery OS for AI digital employees (duaer-spec ${PKG.version})
+const POLICY_MODES = new Set(['off', 'coach', 'strict'])
 
-Hire agents into a repo, assign Briefs (Specs), accept only when the gate passes.
+const USAGE = `duaer — digital-employee delivery (duaer-spec ${PKG.version})
 
-Usage:
-  duaer init [dir] [options]     Hire / onboard into a project
-  duaer check [dir] [options]    Workplace + delivery status
-  duaer version                  Print version
-  duaer help                     Show this help
+Everyday:
+  duaer init [--here]     Hire into a project
+  duaer status [dir]      Is the active job accepted?
 
-Init options:
-  --all          Full hire: agent ops + method (default)
-  --method       Lite: method only (.duaer, skills, DUADER.md, duaer-spec rule)
-  --ops          Ops only (AGENTS.md, docs/agent, ops rules)
-  --force        Overwrite existing managed files
-  --branch <n>   Integration branch for baseline note (default: main)
-  --here         Same as dir=.
+In Cursor:  /duaer-do <what you want>
 
-Check options:
-  --workplace    Only verify install files
-  --delivery     Only report feature Brief / open tasks / delivery.json
-  --gate         Fail unless every feature is accepted (merge gate)
-  (default)      Workplace + delivery report; exit 1 on workplace miss
-                 or delivery blockers (missing Spec / open tasks / open stamp)
+Advanced:
+  duaer check [dir] [--workplace|--job|--all-jobs|--strict]
+  duaer job [dir]                    (same as status)
+  duaer policy [dir] [off|coach|strict]
+  duaer version
+
+Init: --all (default) | --method | --ops | --force | --branch <n> | --here
 
 Examples:
   npx duaer-spec init --here
-  duaer check .
-  duaer check . --gate
+  duaer status
 `
 
 function parseArgs(argv) {
@@ -65,7 +55,10 @@ function parseArgs(argv) {
     branch: 'main',
     workplace: false,
     delivery: false,
-    gate: false,
+    job: false,
+    allJobs: false,
+    strict: false,
+    policyMode: null,
   }
   const rest = args.slice(1)
   for (let i = 0; i < rest.length; i++) {
@@ -77,12 +70,18 @@ function parseArgs(argv) {
     else if (a === '--here') out.dir = '.'
     else if (a === '--workplace') out.workplace = true
     else if (a === '--delivery') out.delivery = true
-    else if (a === '--gate') out.gate = true
+    else if (a === '--job') out.job = true
+    else if (a === '--all-jobs') out.allJobs = true
+    else if (a === '--strict' || a === '--gate') out.strict = true
     else if (a === '--branch') {
       out.branch = rest[++i]
       if (!out.branch) throw new Error('--branch requires a value')
+    } else if (POLICY_MODES.has(a) && out.cmd === 'policy') {
+      out.policyMode = a
     } else if (a.startsWith('-')) {
       throw new Error(`Unknown flag: ${a}`)
+    } else if (out.cmd === 'policy' && POLICY_MODES.has(a)) {
+      out.policyMode = a
     } else {
       out.dir = a
     }
@@ -124,10 +123,62 @@ function writeIfNeeded(path, content, { force }) {
   console.log(`wrote ${path}`)
 }
 
+function readJson(path, fallback = null) {
+  if (!existsSync(path)) return fallback
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return fallback
+  }
+}
+
+function defaultPolicy() {
+  return {
+    schemaVersion: 1,
+    mode: 'coach',
+    scope: 'active',
+    notes:
+      'Job-level handoff. off=record only; coach=guide (default); strict=do not claim done until accepted. Not a git merge lock.',
+  }
+}
+
+function policyPath(target) {
+  return join(target, '.duaer', 'delivery-policy.json')
+}
+
+function activeJobPath(target) {
+  return join(target, '.duaer', 'active-job.json')
+}
+
+function loadPolicy(target) {
+  const p = readJson(policyPath(target), null)
+  if (!p) return defaultPolicy()
+  const mode = POLICY_MODES.has(p.mode) ? p.mode : 'coach'
+  return { ...defaultPolicy(), ...p, mode }
+}
+
+function writePolicy(target, mode) {
+  const next = { ...defaultPolicy(), mode, updatedAt: new Date().toISOString() }
+  ensureDir(join(target, '.duaer'))
+  writeFileSync(policyPath(target), JSON.stringify(next, null, 2) + '\n')
+  return next
+}
+
+function writeDefaultPolicy(target, { force }) {
+  const path = policyPath(target)
+  if (existsSync(path) && !force) {
+    console.log(`skip (exists): ${path}`)
+    return
+  }
+  writeFileSync(path, JSON.stringify(defaultPolicy(), null, 2) + '\n')
+  console.log('  .duaer/delivery-policy.json (mode=coach)')
+}
+
 function installMethod(target, opts) {
   console.log('Installing Duaer method…')
   copyPath(join(PKG_ROOT, '.duaer'), join(target, '.duaer'), opts)
   console.log('  .duaer/')
+  writeDefaultPolicy(target, opts)
 
   ensureDir(join(target, '.cursor', 'skills'))
   const skillsRoot = join(PKG_ROOT, '.cursor', 'skills')
@@ -232,19 +283,12 @@ function cmdInit(opts) {
   }
 
   console.log(`
-Hired.
-
-Next (digital employee loop):
-  1. Orient  — edit .duaer/memory/constitution.md and project-context.md
-  2. Workplace — confirm docs/baseline.md (integration branch: ${opts.branch})
-  3. Assign  — /duaer-specify  (Brief: what / why / acceptance)
-  4. Work    — /duaer-plan → /duaer-tasks → /duaer-implement
-  5. Accept  — /duaer-converge  (writes delivery.json; gaps stay open)
-  6. Gate    — duaer check . --gate  before merge
-  7. Policy  — AGENTS.md wins over DUADER.md when they conflict
-
-No Spec = not assigned. Open tasks or open delivery.json = not accepted.
-See DUADER.md and AGENTS.md in the target project.
+Hired. Everyday loop:
+
+  1. In Cursor:  /duaer-do <what you want>
+  2. Optional:   duaer status
+
+That is enough for normal work. Advanced: ADOPT.md / DUADER.md
 `)
 }
 
@@ -265,6 +309,55 @@ function readDelivery(path) {
   }
 }
 
+function featureVerdict(name, dir) {
+  const specPath = join(dir, 'spec.md')
+  const tasksPath = join(dir, 'tasks.md')
+  const deliveryPath = join(dir, 'delivery.json')
+  const tasks = countOpenTasks(tasksPath)
+  const delivery = readDelivery(deliveryPath)
+  const hasSpec = existsSync(specPath)
+  const stamp = delivery?.status || 'none'
+  let verdict = 'accepted'
+  const blockers = []
+
+  if (!hasSpec) {
+    verdict = 'blocked'
+    blockers.push('missing spec.md')
+  }
+  if (tasks && tasks.open > 0) {
+    verdict = 'blocked'
+    blockers.push(`${tasks.open} open task(s)`)
+  }
+  if (stamp === 'open' || stamp === 'invalid') {
+    verdict = 'blocked'
+    blockers.push(`delivery.json status=${stamp}`)
+  }
+  if (hasSpec && tasks && tasks.open === 0 && (stamp === 'none' || !delivery)) {
+    verdict = 'unaccepted'
+    blockers.push('no delivery.json (run /duaer-converge)')
+  }
+  if (hasSpec && !tasks && (stamp === 'none' || !delivery)) {
+    verdict = 'unaccepted'
+    blockers.push('no tasks.md / no delivery.json')
+  }
+  if (stamp === 'accepted' && tasks && tasks.open === 0 && hasSpec) {
+    verdict = 'accepted'
+    blockers.length = 0
+  } else if (stamp === 'accepted' && (!tasks || tasks.open === 0) && hasSpec && !tasks) {
+    // accepted stamp with no tasks file — treat as accepted only if stamp says so
+    // keep unaccepted path above for !tasks && no stamp
+  }
+
+  // Stamp accepted but open tasks remain → blocked (fake stamp)
+  if (stamp === 'accepted' && tasks && tasks.open > 0) {
+    verdict = 'blocked'
+    blockers.length = 0
+    blockers.push('delivery.json accepted but open tasks remain')
+  }
+
+  return { name, hasSpec, tasks, stamp, verdict, blockers }
+}
+
 function listFeatures(target) {
   const root = join(target, '.duaer', 'specs')
   if (!existsSync(root)) return []
@@ -277,53 +370,28 @@ function listFeatures(target) {
       }
     })
     .sort()
-    .map((name) => {
-      const dir = join(root, name)
-      const specPath = join(dir, 'spec.md')
-      const tasksPath = join(dir, 'tasks.md')
-      const deliveryPath = join(dir, 'delivery.json')
-      const tasks = countOpenTasks(tasksPath)
-      const delivery = readDelivery(deliveryPath)
-      const hasSpec = existsSync(specPath)
-      const stamp = delivery?.status || 'none'
-      let verdict = 'accepted'
-      const blockers = []
-
-      if (!hasSpec) {
-        verdict = 'blocked'
-        blockers.push('missing spec.md')
-      }
-      if (tasks && tasks.open > 0) {
-        verdict = 'blocked'
-        blockers.push(`${tasks.open} open task(s)`)
-      }
-      if (stamp === 'open' || stamp === 'invalid') {
-        verdict = 'blocked'
-        blockers.push(`delivery.json status=${stamp}`)
-      }
-      if (hasSpec && tasks && tasks.open === 0 && (stamp === 'none' || !delivery)) {
-        // Brief exists and tasks clear, but never stamped by converge
-        verdict = 'unaccepted'
-        blockers.push('no delivery.json (run /duaer-converge)')
-      }
-      if (hasSpec && !tasks && (stamp === 'none' || !delivery)) {
-        verdict = 'unaccepted'
-        blockers.push('no tasks.md / no delivery.json')
-      }
-      if (stamp === 'accepted' && tasks && tasks.open === 0 && hasSpec) {
-        verdict = 'accepted'
-        blockers.length = 0
-      }
+    .map((name) => featureVerdict(name, join(root, name)))
+}
 
-      return {
-        name,
-        hasSpec,
-        tasks,
-        stamp,
-        verdict,
-        blockers,
-      }
-    })
+function resolveActiveJobName(target, features) {
+  const marker = readJson(activeJobPath(target), null)
+  if (marker?.feature && features.some((f) => f.name === marker.feature)) {
+    return marker.feature
+  }
+  if (features.length === 0) return null
+  // Prefer newest directory name (lexicographic works for NNN-slug)
+  return features[features.length - 1].name
+}
+
+function printFeature(f, { label } = {}) {
+  const taskInfo = f.tasks
+    ? `tasks open=${f.tasks.open} done=${f.tasks.done}`
+    : 'no tasks.md'
+  const prefix = label ? `${label} ` : ''
+  console.log(
+    `${prefix}${f.verdict.padEnd(10)} ${f.name}  spec=${f.hasSpec ? 'yes' : 'NO'}  stamp=${f.stamp}  ${taskInfo}`,
+  )
+  for (const b of f.blockers) console.log(`           · ${b}`)
 }
 
 function checkWorkplace(target) {
@@ -346,51 +414,91 @@ function checkWorkplace(target) {
   return missing
 }
 
-function checkDelivery(target, { gate }) {
+function checkDelivery(target, { allJobs, policy }) {
   const features = listFeatures(target)
-  console.log('\n## Delivery\n')
+  const activeName = resolveActiveJobName(target, features)
+  const active = features.find((f) => f.name === activeName) || null
+
+  console.log('\n## Handoff (jobs)\n')
+  console.log(`policy: ${policy.mode}  scope: ${allJobs ? 'all' : 'active'}`)
+
   if (features.length === 0) {
-    console.log('ok   no features under .duaer/specs/ (nothing to accept)')
-    return { blocked: 0, unaccepted: 0, features: 0 }
+    console.log('ok   no features under .duaer/specs/ (nothing to hand off)')
+    return { blocked: 0, unaccepted: 0, features: 0, active: null, unfinished: false }
   }
 
+  if (allJobs) {
+    for (const f of features) {
+      printFeature(f, { label: f.name === activeName ? '★' : ' ' })
+    }
+  } else if (active) {
+    printFeature(active, { label: '★' })
+    console.log(`\nactive job: ${active.name}  (from .duaer/active-job.json or latest spec)`)
+  } else {
+    console.log('ok   no resolvable active job')
+  }
+
+  const focus = allJobs ? features : active ? [active] : []
   let blocked = 0
   let unaccepted = 0
-  for (const f of features) {
-    const taskInfo = f.tasks
-      ? `tasks open=${f.tasks.open} done=${f.tasks.done}`
-      : 'no tasks.md'
-    const line = `${f.verdict.padEnd(10)} ${f.name}  spec=${f.hasSpec ? 'yes' : 'NO'}  stamp=${f.stamp}  ${taskInfo}`
-    console.log(line)
-    if (f.blockers.length) {
-      for (const b of f.blockers) console.log(`           · ${b}`)
-    }
+  for (const f of focus) {
     if (f.verdict === 'blocked') blocked++
     if (f.verdict === 'unaccepted') unaccepted++
   }
+  const unfinished = blocked + unaccepted > 0
+  return { blocked, unaccepted, features: focus.length, active, unfinished }
+}
 
-  if (gate) {
-    console.log('\nGate mode: every feature must be accepted.')
+function handoffAdvice(policy, unfinished, strictFlag) {
+  if (!unfinished) {
+    console.log('\nActive job accepted — employee may report delivery complete.')
+    return
+  }
+  if (policy.mode === 'off' && !strictFlag) {
+    console.log('\nHandoff incomplete (policy=off) — recorded only.')
+    return
+  }
+  if (policy.mode === 'coach' && !strictFlag) {
+    console.log(`
+Coach: this job is not accepted yet.
+  → close open tasks, run /duaer-converge, then duaer job .
+  → do not tell the user the work is "done" until status=accepted
+  → git is not blocked; this is job etiquette, not a merge lock
+`)
+    return
   }
-  return { blocked, unaccepted, features: features.length }
+  console.log(`
+Strict: active job not accepted — exit 1.
+  → /duaer-converge until delivery.json status=accepted and tasks clear
+`)
 }
 
 function cmdCheck(opts) {
   const target = resolve(opts.dir)
-  // Default: workplace + delivery. --gate alone is delivery-only (merge gate).
-  const runWorkplace = opts.workplace || (!opts.delivery && !opts.gate)
-  const runDelivery = opts.delivery || opts.gate || !opts.workplace
+  const policy = loadPolicy(target)
+  const strictFlag = opts.strict || policy.mode === 'strict'
+
+  // default: workplace + delivery; --workplace alone; job/delivery/strict/all-jobs → delivery
+  let wp = false
+  let del = false
+  if (opts.workplace && !opts.delivery && !opts.job && !opts.allJobs && !opts.strict) {
+    wp = true
+  } else if (opts.delivery || opts.job || opts.allJobs || opts.strict) {
+    del = true
+    if (opts.workplace) wp = true
+  } else {
+    wp = true
+    del = true
+  }
 
-  console.log(`Checking ${target}${opts.gate ? ' (gate)' : ''}\n`)
+  console.log(`Checking ${target}${strictFlag ? ' (strict handoff)' : ''}\n`)
 
   let workplaceMissing = 0
-  if (runWorkplace) {
-    workplaceMissing = checkWorkplace(target)
-  }
+  if (wp) workplaceMissing = checkWorkplace(target)
 
-  let delivery = { blocked: 0, unaccepted: 0, features: 0 }
-  if (runDelivery) {
-    delivery = checkDelivery(target, { gate: opts.gate })
+  let delivery = { unfinished: false }
+  if (del) {
+    delivery = checkDelivery(target, { allJobs: opts.allJobs, policy })
   }
 
   let fail = false
@@ -399,36 +507,77 @@ function cmdCheck(opts) {
     fail = true
   }
 
-  if (runDelivery) {
-    if (delivery.blocked) {
-      console.log(`\n${delivery.blocked} feature(s) blocked — close open tasks / fix Spec / re-run converge`)
+  if (del) {
+    handoffAdvice(policy, delivery.unfinished, opts.strict)
+    if (delivery.unfinished && strictFlag) {
       fail = true
     }
-    if (opts.gate && delivery.unaccepted) {
-      console.log(
-        `\n${delivery.unaccepted} feature(s) not accepted — run /duaer-converge until delivery.json status=accepted`,
-      )
-      fail = true
-    } else if (!opts.gate && delivery.unaccepted) {
-      console.log(
-        `\n${delivery.unaccepted} feature(s) not yet accepted (warning). Use --gate to fail the merge check.`,
-      )
-    }
   }
 
   if (!fail) {
-    if (opts.gate) {
-      console.log('\nGate passed — deliverable.')
-    } else if (runWorkplace && !workplaceMissing) {
-      console.log('\nWorkplace ready. Use --gate before merge when features exist.')
+    if (wp && !workplaceMissing && !del) {
+      console.log('\nWorkplace ready.')
+    } else if (!delivery.unfinished) {
+      console.log('\nCheck ok.')
     } else {
-      console.log('\nDelivery report done.')
+      console.log('\nCheck ok (handoff still open under coach/off — see above).')
     }
   } else {
     process.exitCode = 1
   }
 }
 
+function cmdJob(opts) {
+  const target = resolve(opts.dir)
+  const policy = loadPolicy(target)
+  const features = listFeatures(target)
+  const activeName = resolveActiveJobName(target, features)
+  const active = features.find((f) => f.name === activeName) || null
+
+  console.log(`Status @ ${target}`)
+  if (!active) {
+    console.log('No active job yet. In Cursor run: /duaer-do <what you want>')
+    return
+  }
+  if (active.verdict === 'accepted') {
+    console.log(`✅ accepted  ${active.name}`)
+    console.log('Ready for your review.')
+  } else {
+    console.log(`⏳ not done  ${active.name}`)
+    for (const b of active.blockers) console.log(`   · ${b}`)
+    console.log('Next: /duaer-do (resume) or /duaer-converge')
+  }
+  if (policy.mode === 'strict' && active.verdict !== 'accepted') {
+    console.log('(policy=strict — do not claim done yet)')
+  }
+}
+
+function cmdPolicy(opts) {
+  const target = resolve(opts.dir)
+  if (opts.policyMode) {
+    if (!POLICY_MODES.has(opts.policyMode)) {
+      throw new Error(`Unknown policy mode: ${opts.policyMode}`)
+    }
+    const next = writePolicy(target, opts.policyMode)
+    console.log(`Wrote ${policyPath(target)}`)
+    console.log(`mode: ${next.mode}`)
+    return
+  }
+  const policy = loadPolicy(target)
+  const exists = existsSync(policyPath(target))
+  console.log(`Policy @ ${target}`)
+  console.log(`file:  ${exists ? policyPath(target) : '(defaults; run init or: duaer policy . coach)'}`)
+  console.log(`mode:  ${policy.mode}`)
+  console.log(`scope: ${policy.scope || 'active'}`)
+  console.log(`
+Modes:
+  off     record only
+  coach   guide; do not claim done until accepted (default)
+  strict  check fails + agents must not report done until accepted
+Not a git merge lock.
+`)
+}
+
 function main() {
   let opts
   try {
@@ -447,6 +596,13 @@ function main() {
       case 'check':
         cmdCheck(opts)
         break
+      case 'job':
+      case 'status':
+        cmdJob(opts)
+        break
+      case 'policy':
+        cmdPolicy(opts)
+        break
       case 'version':
       case '--version':
       case '-v':

package/docs/agent/change-checklist.md

@@ -94,7 +94,7 @@ See [spec update guidance](workflow.md#3-spec-update-guidance).
 
 ## 6. Merge / PR
 
-- [ ] `duaer check . --gate` passed (or no `.duaer/specs/` features yet).
+- [ ] Active job handoff considered: `duaer job .` (coach/strict: do not claim done if unfinished).
 - [ ] Branch refreshed against latest `main`.
 - [ ] Merged into local `main` (and/or remote PR/MR when required).
 - [ ] Only this request's logical changes included.
@@ -122,7 +122,7 @@ See [spec update guidance](workflow.md#3-spec-update-guidance).
 | 3 | Impacted specs updated | [R1](workflow.md#r1--spec-first--spec-sync) |
 | 4 | E2E docs updated or confirmed unnecessary | [R3](workflow.md#r3--e2e-coverage-doc) |
 | 5 | Targeted validation done or waived with reason | Development loop |
-| 5a | `duaer check . --gate` when features exist | Delivery OS gate |
+| 5a | Active job handoff via `duaer job` (coach/strict) | Delivery OS — not a git lock |
 | 6 | Conventional commits | [R2](workflow.md#r2--commit-per-change) |
 | 7 | No secrets or local data | [§4](workflow.md#4-what-never-to-commit) |
 | 8 | Merged into `main`; worktree and branch removed | [R4](workflow.md#r4--request-branch--worktree--merge-gate) · [§6.1](#61-merge-cleanup) |

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

@@ -25,11 +25,14 @@ the table for their app.
 
 | ID | Title | Status |
 |---|---|---|
-| E2E-001 | After `duaer init`, CLI prints hire → assign → accept next steps | manual |
-| E2E-002 | README positions Duaer as delivery OS for digital employees | manual |
-| E2E-003 | `duaer check --delivery` reports open tasks as blocked | manual |
-| E2E-004 | `duaer check --gate` fails without `delivery.json` accepted | manual |
-| E2E-005 | After converge stamps `accepted`, `--gate` passes | manual |
+| 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 |
 
 ## Traceability
 
@@ -37,8 +40,11 @@ Keep this matrix current when scenarios or specs change.
 
 | Scenario | Spec / feature | Notes |
 |---|---|---|
-| E2E-001 | `bin/duaer.mjs` init banner | Controllable-delivery onboarding |
-| E2E-002 | `README.md` / `ADOPT.md` | Product identity |
-| E2E-003 | `bin/duaer.mjs` delivery check | Open `- [ ]` tasks |
-| E2E-004 | `bin/duaer.mjs` `--gate` | Merge gate |
-| E2E-005 | `/duaer-converge` → `delivery.json` | Accept stamp |
+| 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 |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duaer-spec",
-  "version": "0.2.0",
-  "description": "Delivery OS for AI digital employees: Spec briefs, agent ops, check --gate handoffs",
+  "version": "0.4.0",
+  "description": "Simple digital-employee delivery: /duaer-do + duaer status",
   "type": "module",
   "bin": {
     "duaer": "bin/duaer.mjs",